001// 002// This file was generated by the JavaTM Architecture for XML Binding(JAXB) Reference Implementation, v2.2.10-b140310.1920 003// See <a href="http://java.sun.com/xml/jaxb">http://java.sun.com/xml/jaxb</a> 004// Any modifications to this file will be lost upon recompilation of the source schema. 005// Generated on: 2019.11.20 at 05:50:24 PM CET 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="adapter" 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}axionJDBCAdapter"/> 061 * <element ref="{http://activemq.apache.org/schema/core}blobJDBCAdapter"/> 062 * <element ref="{http://activemq.apache.org/schema/core}bytesJDBCAdapter"/> 063 * <element ref="{http://activemq.apache.org/schema/core}db2JDBCAdapter"/> 064 * <element ref="{http://activemq.apache.org/schema/core}defaultJDBCAdapter"/> 065 * <element ref="{http://activemq.apache.org/schema/core}hsqldb-jdbc-adapter"/> 066 * <element ref="{http://activemq.apache.org/schema/core}imageBasedJDBCAdaptor"/> 067 * <element ref="{http://activemq.apache.org/schema/core}informixJDBCAdapter"/> 068 * <element ref="{http://activemq.apache.org/schema/core}maxdb-jdbc-adapter"/> 069 * <element ref="{http://activemq.apache.org/schema/core}mysql-jdbc-adapter"/> 070 * <element ref="{http://activemq.apache.org/schema/core}oracleBlobJDBCAdapter"/> 071 * <element ref="{http://activemq.apache.org/schema/core}oracleJDBCAdapter"/> 072 * <element ref="{http://activemq.apache.org/schema/core}postgresql-jdbc-adapter"/> 073 * <element ref="{http://activemq.apache.org/schema/core}sqlServerJDBCAdapter"/> 074 * <element ref="{http://activemq.apache.org/schema/core}streamJDBCAdapter"/> 075 * <element ref="{http://activemq.apache.org/schema/core}sybase-jdbc-adapter"/> 076 * <element ref="{http://activemq.apache.org/schema/core}transact-jdbc-adapter"/> 077 * <any namespace='##other'/> 078 * </choice> 079 * </restriction> 080 * </complexContent> 081 * </complexType> 082 * </element> 083 * <element name="brokerService" minOccurs="0"> 084 * <complexType> 085 * <complexContent> 086 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 087 * <choice minOccurs="0"> 088 * <element ref="{http://activemq.apache.org/schema/core}broker"/> 089 * <element ref="{http://activemq.apache.org/schema/core}brokerService"/> 090 * <any namespace='##other'/> 091 * </choice> 092 * </restriction> 093 * </complexContent> 094 * </complexType> 095 * </element> 096 * <element name="dataSource" minOccurs="0"> 097 * <complexType> 098 * <complexContent> 099 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 100 * <sequence minOccurs="0"> 101 * <any maxOccurs="unbounded" minOccurs="0"/> 102 * </sequence> 103 * </restriction> 104 * </complexContent> 105 * </complexType> 106 * </element> 107 * <element name="databaseLocker" minOccurs="0"> 108 * <complexType> 109 * <complexContent> 110 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 111 * <choice minOccurs="0"> 112 * <element ref="{http://activemq.apache.org/schema/core}database-locker"/> 113 * <element ref="{http://activemq.apache.org/schema/core}lease-database-locker"/> 114 * <element ref="{http://activemq.apache.org/schema/core}shared-file-locker"/> 115 * <element ref="{http://activemq.apache.org/schema/core}transact-database-locker"/> 116 * <any namespace='##other'/> 117 * </choice> 118 * </restriction> 119 * </complexContent> 120 * </complexType> 121 * </element> 122 * <element name="ds" minOccurs="0"> 123 * <complexType> 124 * <complexContent> 125 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 126 * <sequence minOccurs="0"> 127 * <any maxOccurs="unbounded" minOccurs="0"/> 128 * </sequence> 129 * </restriction> 130 * </complexContent> 131 * </complexType> 132 * </element> 133 * <element name="lockDataSource" minOccurs="0"> 134 * <complexType> 135 * <complexContent> 136 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 137 * <sequence minOccurs="0"> 138 * <any maxOccurs="unbounded" minOccurs="0"/> 139 * </sequence> 140 * </restriction> 141 * </complexContent> 142 * </complexType> 143 * </element> 144 * <element name="locker" minOccurs="0"> 145 * <complexType> 146 * <complexContent> 147 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 148 * <choice minOccurs="0"> 149 * <element ref="{http://activemq.apache.org/schema/core}database-locker"/> 150 * <element ref="{http://activemq.apache.org/schema/core}lease-database-locker"/> 151 * <element ref="{http://activemq.apache.org/schema/core}shared-file-locker"/> 152 * <element ref="{http://activemq.apache.org/schema/core}transact-database-locker"/> 153 * <any namespace='##other'/> 154 * </choice> 155 * </restriction> 156 * </complexContent> 157 * </complexType> 158 * </element> 159 * <element name="scheduledThreadPoolExecutor" minOccurs="0"> 160 * <complexType> 161 * <complexContent> 162 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 163 * <sequence minOccurs="0"> 164 * <any maxOccurs="unbounded" minOccurs="0"/> 165 * </sequence> 166 * </restriction> 167 * </complexContent> 168 * </complexType> 169 * </element> 170 * <element name="statements" minOccurs="0"> 171 * <complexType> 172 * <complexContent> 173 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 174 * <choice minOccurs="0"> 175 * <element ref="{http://activemq.apache.org/schema/core}statements"/> 176 * <any namespace='##other'/> 177 * </choice> 178 * </restriction> 179 * </complexContent> 180 * </complexType> 181 * </element> 182 * <element name="usageManager" minOccurs="0"> 183 * <complexType> 184 * <complexContent> 185 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 186 * <choice minOccurs="0"> 187 * <element ref="{http://activemq.apache.org/schema/core}systemUsage"/> 188 * <any namespace='##other'/> 189 * </choice> 190 * </restriction> 191 * </complexContent> 192 * </complexType> 193 * </element> 194 * <element name="wireFormat" minOccurs="0"> 195 * <complexType> 196 * <complexContent> 197 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 198 * <sequence minOccurs="0"> 199 * <any maxOccurs="unbounded" minOccurs="0"/> 200 * </sequence> 201 * </restriction> 202 * </complexContent> 203 * </complexType> 204 * </element> 205 * <any namespace='##other' maxOccurs="unbounded" minOccurs="0"/> 206 * </choice> 207 * </choice> 208 * <attribute name="adapter" type="{http://www.w3.org/2001/XMLSchema}string" /> 209 * <attribute name="auditRecoveryDepth" type="{http://www.w3.org/2001/XMLSchema}integer" /> 210 * <attribute name="brokerName" type="{http://www.w3.org/2001/XMLSchema}string" /> 211 * <attribute name="brokerService" type="{http://www.w3.org/2001/XMLSchema}string" /> 212 * <attribute name="changeAutoCommitAllowed" type="{http://www.w3.org/2001/XMLSchema}boolean" /> 213 * <attribute name="cleanupPeriod" type="{http://www.w3.org/2001/XMLSchema}integer" /> 214 * <attribute name="createTablesOnStartup" type="{http://www.w3.org/2001/XMLSchema}boolean" /> 215 * <attribute name="dataDirectory" type="{http://www.w3.org/2001/XMLSchema}string" /> 216 * <attribute name="dataDirectoryFile" type="{http://www.w3.org/2001/XMLSchema}string" /> 217 * <attribute name="dataSource" type="{http://www.w3.org/2001/XMLSchema}string" /> 218 * <attribute name="databaseLocker" type="{http://www.w3.org/2001/XMLSchema}string" /> 219 * <attribute name="directory" type="{http://www.w3.org/2001/XMLSchema}string" /> 220 * <attribute name="ds" type="{http://www.w3.org/2001/XMLSchema}string" /> 221 * <attribute name="enableAudit" type="{http://www.w3.org/2001/XMLSchema}boolean" /> 222 * <attribute name="lockAcquireSleepInterval" type="{http://www.w3.org/2001/XMLSchema}long" /> 223 * <attribute name="lockDataSource" type="{http://www.w3.org/2001/XMLSchema}string" /> 224 * <attribute name="lockKeepAlivePeriod" type="{http://www.w3.org/2001/XMLSchema}long" /> 225 * <attribute name="locker" type="{http://www.w3.org/2001/XMLSchema}string" /> 226 * <attribute name="maxAuditDepth" type="{http://www.w3.org/2001/XMLSchema}integer" /> 227 * <attribute name="maxProducersToAudit" type="{http://www.w3.org/2001/XMLSchema}integer" /> 228 * <attribute name="maxRows" type="{http://www.w3.org/2001/XMLSchema}integer" /> 229 * <attribute name="scheduledThreadPoolExecutor" type="{http://www.w3.org/2001/XMLSchema}string" /> 230 * <attribute name="statements" type="{http://www.w3.org/2001/XMLSchema}string" /> 231 * <attribute name="transactionIsolation" type="{http://www.w3.org/2001/XMLSchema}integer" /> 232 * <attribute name="usageManager" type="{http://www.w3.org/2001/XMLSchema}string" /> 233 * <attribute name="useDatabaseLock" type="{http://www.w3.org/2001/XMLSchema}boolean" /> 234 * <attribute name="useExternalMessageReferences" type="{http://www.w3.org/2001/XMLSchema}boolean" /> 235 * <attribute name="useLock" type="{http://www.w3.org/2001/XMLSchema}boolean" /> 236 * <attribute name="wireFormat" type="{http://www.w3.org/2001/XMLSchema}string" /> 237 * <attribute name="id" type="{http://www.w3.org/2001/XMLSchema}ID" /> 238 * <anyAttribute processContents='lax' namespace='##other'/> 239 * </restriction> 240 * </complexContent> 241 * </complexType> 242 * </pre> 243 * 244 * 245 */ 246@XmlAccessorType(XmlAccessType.FIELD) 247@XmlType(name = "", propOrder = { 248 "adapterOrBrokerServiceOrDataSource" 249}) 250@XmlRootElement(name = "jdbcPersistenceAdapter") 251public class DtoJdbcPersistenceAdapter implements Equals, HashCode, ToString 252{ 253 254 @XmlElementRefs({ 255 @XmlElementRef(name = "usageManager", namespace = "http://activemq.apache.org/schema/core", type = JAXBElement.class, required = false), 256 @XmlElementRef(name = "wireFormat", namespace = "http://activemq.apache.org/schema/core", type = JAXBElement.class, required = false), 257 @XmlElementRef(name = "locker", namespace = "http://activemq.apache.org/schema/core", type = JAXBElement.class, required = false), 258 @XmlElementRef(name = "brokerService", namespace = "http://activemq.apache.org/schema/core", type = JAXBElement.class, required = false), 259 @XmlElementRef(name = "dataSource", namespace = "http://activemq.apache.org/schema/core", type = JAXBElement.class, required = false), 260 @XmlElementRef(name = "databaseLocker", namespace = "http://activemq.apache.org/schema/core", type = JAXBElement.class, required = false), 261 @XmlElementRef(name = "statements", namespace = "http://activemq.apache.org/schema/core", type = JAXBElement.class, required = false), 262 @XmlElementRef(name = "adapter", namespace = "http://activemq.apache.org/schema/core", type = JAXBElement.class, required = false), 263 @XmlElementRef(name = "scheduledThreadPoolExecutor", namespace = "http://activemq.apache.org/schema/core", type = JAXBElement.class, required = false), 264 @XmlElementRef(name = "ds", namespace = "http://activemq.apache.org/schema/core", type = JAXBElement.class, required = false), 265 @XmlElementRef(name = "lockDataSource", namespace = "http://activemq.apache.org/schema/core", type = JAXBElement.class, required = false) 266 }) 267 @XmlAnyElement(lax = true) 268 protected List<Object> adapterOrBrokerServiceOrDataSource; 269 @XmlAttribute(name = "adapter") 270 protected String adapter; 271 @XmlAttribute(name = "auditRecoveryDepth") 272 protected BigInteger auditRecoveryDepth; 273 @XmlAttribute(name = "brokerName") 274 protected String brokerName; 275 @XmlAttribute(name = "brokerService") 276 protected String brokerService; 277 @XmlAttribute(name = "changeAutoCommitAllowed") 278 protected Boolean changeAutoCommitAllowed; 279 @XmlAttribute(name = "cleanupPeriod") 280 protected BigInteger cleanupPeriod; 281 @XmlAttribute(name = "createTablesOnStartup") 282 protected Boolean createTablesOnStartup; 283 @XmlAttribute(name = "dataDirectory") 284 protected String dataDirectory; 285 @XmlAttribute(name = "dataDirectoryFile") 286 protected String dataDirectoryFile; 287 @XmlAttribute(name = "dataSource") 288 protected String dataSource; 289 @XmlAttribute(name = "databaseLocker") 290 protected String databaseLocker; 291 @XmlAttribute(name = "directory") 292 protected String directory; 293 @XmlAttribute(name = "ds") 294 protected String ds; 295 @XmlAttribute(name = "enableAudit") 296 protected Boolean enableAudit; 297 @XmlAttribute(name = "lockAcquireSleepInterval") 298 protected Long lockAcquireSleepInterval; 299 @XmlAttribute(name = "lockDataSource") 300 protected String lockDataSource; 301 @XmlAttribute(name = "lockKeepAlivePeriod") 302 protected Long lockKeepAlivePeriod; 303 @XmlAttribute(name = "locker") 304 protected String locker; 305 @XmlAttribute(name = "maxAuditDepth") 306 protected BigInteger maxAuditDepth; 307 @XmlAttribute(name = "maxProducersToAudit") 308 protected BigInteger maxProducersToAudit; 309 @XmlAttribute(name = "maxRows") 310 protected BigInteger maxRows; 311 @XmlAttribute(name = "scheduledThreadPoolExecutor") 312 protected String scheduledThreadPoolExecutor; 313 @XmlAttribute(name = "statements") 314 protected String statements; 315 @XmlAttribute(name = "transactionIsolation") 316 protected BigInteger transactionIsolation; 317 @XmlAttribute(name = "usageManager") 318 protected String usageManager; 319 @XmlAttribute(name = "useDatabaseLock") 320 protected Boolean useDatabaseLock; 321 @XmlAttribute(name = "useExternalMessageReferences") 322 protected Boolean useExternalMessageReferences; 323 @XmlAttribute(name = "useLock") 324 protected Boolean useLock; 325 @XmlAttribute(name = "wireFormat") 326 protected String wireFormat; 327 @XmlAttribute(name = "id") 328 @XmlJavaTypeAdapter(CollapsedStringAdapter.class) 329 @XmlID 330 @XmlSchemaType(name = "ID") 331 protected String id; 332 @XmlAnyAttribute 333 private Map<QName, String> otherAttributes = new HashMap<QName, String>(); 334 335 /** 336 * Gets the value of the adapterOrBrokerServiceOrDataSource property. 337 * 338 * <p> 339 * This accessor method returns a reference to the live list, 340 * not a snapshot. Therefore any modification you make to the 341 * returned list will be present inside the JAXB object. 342 * This is why there is not a <CODE>set</CODE> method for the adapterOrBrokerServiceOrDataSource property. 343 * 344 * <p> 345 * For example, to add a new item, do as follows: 346 * <pre> 347 * getAdapterOrBrokerServiceOrDataSource().add(newItem); 348 * </pre> 349 * 350 * 351 * <p> 352 * Objects of the following type(s) are allowed in the list 353 * {@link JAXBElement }{@code <}{@link DtoJdbcPersistenceAdapter.UsageManager }{@code >} 354 * {@link JAXBElement }{@code <}{@link DtoJdbcPersistenceAdapter.WireFormat }{@code >} 355 * {@link JAXBElement }{@code <}{@link DtoJdbcPersistenceAdapter.Locker }{@code >} 356 * {@link JAXBElement }{@code <}{@link DtoJdbcPersistenceAdapter.BrokerService }{@code >} 357 * {@link JAXBElement }{@code <}{@link DtoJdbcPersistenceAdapter.DataSource }{@code >} 358 * {@link JAXBElement }{@code <}{@link DtoJdbcPersistenceAdapter.DatabaseLocker }{@code >} 359 * {@link Object } 360 * {@link JAXBElement }{@code <}{@link DtoJdbcPersistenceAdapter.Statements }{@code >} 361 * {@link JAXBElement }{@code <}{@link DtoJdbcPersistenceAdapter.Adapter }{@code >} 362 * {@link JAXBElement }{@code <}{@link DtoJdbcPersistenceAdapter.ScheduledThreadPoolExecutor }{@code >} 363 * {@link JAXBElement }{@code <}{@link DtoJdbcPersistenceAdapter.Ds }{@code >} 364 * {@link JAXBElement }{@code <}{@link DtoJdbcPersistenceAdapter.LockDataSource }{@code >} 365 * 366 * 367 */ 368 public List<Object> getAdapterOrBrokerServiceOrDataSource() { 369 if (adapterOrBrokerServiceOrDataSource == null) { 370 adapterOrBrokerServiceOrDataSource = new ArrayList<Object>(); 371 } 372 return this.adapterOrBrokerServiceOrDataSource; 373 } 374 375 /** 376 * Gets the value of the adapter property. 377 * 378 * @return 379 * possible object is 380 * {@link String } 381 * 382 */ 383 public String getAdapter() { 384 return adapter; 385 } 386 387 /** 388 * Sets the value of the adapter property. 389 * 390 * @param value 391 * allowed object is 392 * {@link String } 393 * 394 */ 395 public void setAdapter(String value) { 396 this.adapter = value; 397 } 398 399 /** 400 * Gets the value of the auditRecoveryDepth property. 401 * 402 * @return 403 * possible object is 404 * {@link BigInteger } 405 * 406 */ 407 public BigInteger getAuditRecoveryDepth() { 408 return auditRecoveryDepth; 409 } 410 411 /** 412 * Sets the value of the auditRecoveryDepth property. 413 * 414 * @param value 415 * allowed object is 416 * {@link BigInteger } 417 * 418 */ 419 public void setAuditRecoveryDepth(BigInteger value) { 420 this.auditRecoveryDepth = value; 421 } 422 423 /** 424 * Gets the value of the brokerName property. 425 * 426 * @return 427 * possible object is 428 * {@link String } 429 * 430 */ 431 public String getBrokerName() { 432 return brokerName; 433 } 434 435 /** 436 * Sets the value of the brokerName property. 437 * 438 * @param value 439 * allowed object is 440 * {@link String } 441 * 442 */ 443 public void setBrokerName(String value) { 444 this.brokerName = value; 445 } 446 447 /** 448 * Gets the value of the brokerService property. 449 * 450 * @return 451 * possible object is 452 * {@link String } 453 * 454 */ 455 public String getBrokerService() { 456 return brokerService; 457 } 458 459 /** 460 * Sets the value of the brokerService property. 461 * 462 * @param value 463 * allowed object is 464 * {@link String } 465 * 466 */ 467 public void setBrokerService(String value) { 468 this.brokerService = value; 469 } 470 471 /** 472 * Gets the value of the changeAutoCommitAllowed property. 473 * 474 * @return 475 * possible object is 476 * {@link Boolean } 477 * 478 */ 479 public Boolean isChangeAutoCommitAllowed() { 480 return changeAutoCommitAllowed; 481 } 482 483 /** 484 * Sets the value of the changeAutoCommitAllowed property. 485 * 486 * @param value 487 * allowed object is 488 * {@link Boolean } 489 * 490 */ 491 public void setChangeAutoCommitAllowed(Boolean value) { 492 this.changeAutoCommitAllowed = value; 493 } 494 495 /** 496 * Gets the value of the cleanupPeriod property. 497 * 498 * @return 499 * possible object is 500 * {@link BigInteger } 501 * 502 */ 503 public BigInteger getCleanupPeriod() { 504 return cleanupPeriod; 505 } 506 507 /** 508 * Sets the value of the cleanupPeriod property. 509 * 510 * @param value 511 * allowed object is 512 * {@link BigInteger } 513 * 514 */ 515 public void setCleanupPeriod(BigInteger value) { 516 this.cleanupPeriod = value; 517 } 518 519 /** 520 * Gets the value of the createTablesOnStartup property. 521 * 522 * @return 523 * possible object is 524 * {@link Boolean } 525 * 526 */ 527 public Boolean isCreateTablesOnStartup() { 528 return createTablesOnStartup; 529 } 530 531 /** 532 * Sets the value of the createTablesOnStartup property. 533 * 534 * @param value 535 * allowed object is 536 * {@link Boolean } 537 * 538 */ 539 public void setCreateTablesOnStartup(Boolean value) { 540 this.createTablesOnStartup = value; 541 } 542 543 /** 544 * Gets the value of the dataDirectory property. 545 * 546 * @return 547 * possible object is 548 * {@link String } 549 * 550 */ 551 public String getDataDirectory() { 552 return dataDirectory; 553 } 554 555 /** 556 * Sets the value of the dataDirectory property. 557 * 558 * @param value 559 * allowed object is 560 * {@link String } 561 * 562 */ 563 public void setDataDirectory(String value) { 564 this.dataDirectory = value; 565 } 566 567 /** 568 * Gets the value of the dataDirectoryFile property. 569 * 570 * @return 571 * possible object is 572 * {@link String } 573 * 574 */ 575 public String getDataDirectoryFile() { 576 return dataDirectoryFile; 577 } 578 579 /** 580 * Sets the value of the dataDirectoryFile property. 581 * 582 * @param value 583 * allowed object is 584 * {@link String } 585 * 586 */ 587 public void setDataDirectoryFile(String value) { 588 this.dataDirectoryFile = value; 589 } 590 591 /** 592 * Gets the value of the dataSource property. 593 * 594 * @return 595 * possible object is 596 * {@link String } 597 * 598 */ 599 public String getDataSource() { 600 return dataSource; 601 } 602 603 /** 604 * Sets the value of the dataSource property. 605 * 606 * @param value 607 * allowed object is 608 * {@link String } 609 * 610 */ 611 public void setDataSource(String value) { 612 this.dataSource = value; 613 } 614 615 /** 616 * Gets the value of the databaseLocker property. 617 * 618 * @return 619 * possible object is 620 * {@link String } 621 * 622 */ 623 public String getDatabaseLocker() { 624 return databaseLocker; 625 } 626 627 /** 628 * Sets the value of the databaseLocker property. 629 * 630 * @param value 631 * allowed object is 632 * {@link String } 633 * 634 */ 635 public void setDatabaseLocker(String value) { 636 this.databaseLocker = value; 637 } 638 639 /** 640 * Gets the value of the directory property. 641 * 642 * @return 643 * possible object is 644 * {@link String } 645 * 646 */ 647 public String getDirectory() { 648 return directory; 649 } 650 651 /** 652 * Sets the value of the directory property. 653 * 654 * @param value 655 * allowed object is 656 * {@link String } 657 * 658 */ 659 public void setDirectory(String value) { 660 this.directory = value; 661 } 662 663 /** 664 * Gets the value of the ds property. 665 * 666 * @return 667 * possible object is 668 * {@link String } 669 * 670 */ 671 public String getDs() { 672 return ds; 673 } 674 675 /** 676 * Sets the value of the ds property. 677 * 678 * @param value 679 * allowed object is 680 * {@link String } 681 * 682 */ 683 public void setDs(String value) { 684 this.ds = value; 685 } 686 687 /** 688 * Gets the value of the enableAudit property. 689 * 690 * @return 691 * possible object is 692 * {@link Boolean } 693 * 694 */ 695 public Boolean isEnableAudit() { 696 return enableAudit; 697 } 698 699 /** 700 * Sets the value of the enableAudit property. 701 * 702 * @param value 703 * allowed object is 704 * {@link Boolean } 705 * 706 */ 707 public void setEnableAudit(Boolean value) { 708 this.enableAudit = value; 709 } 710 711 /** 712 * Gets the value of the lockAcquireSleepInterval property. 713 * 714 * @return 715 * possible object is 716 * {@link Long } 717 * 718 */ 719 public Long getLockAcquireSleepInterval() { 720 return lockAcquireSleepInterval; 721 } 722 723 /** 724 * Sets the value of the lockAcquireSleepInterval property. 725 * 726 * @param value 727 * allowed object is 728 * {@link Long } 729 * 730 */ 731 public void setLockAcquireSleepInterval(Long value) { 732 this.lockAcquireSleepInterval = value; 733 } 734 735 /** 736 * Gets the value of the lockDataSource property. 737 * 738 * @return 739 * possible object is 740 * {@link String } 741 * 742 */ 743 public String getLockDataSource() { 744 return lockDataSource; 745 } 746 747 /** 748 * Sets the value of the lockDataSource property. 749 * 750 * @param value 751 * allowed object is 752 * {@link String } 753 * 754 */ 755 public void setLockDataSource(String value) { 756 this.lockDataSource = value; 757 } 758 759 /** 760 * Gets the value of the lockKeepAlivePeriod property. 761 * 762 * @return 763 * possible object is 764 * {@link Long } 765 * 766 */ 767 public Long getLockKeepAlivePeriod() { 768 return lockKeepAlivePeriod; 769 } 770 771 /** 772 * Sets the value of the lockKeepAlivePeriod property. 773 * 774 * @param value 775 * allowed object is 776 * {@link Long } 777 * 778 */ 779 public void setLockKeepAlivePeriod(Long value) { 780 this.lockKeepAlivePeriod = value; 781 } 782 783 /** 784 * Gets the value of the locker property. 785 * 786 * @return 787 * possible object is 788 * {@link String } 789 * 790 */ 791 public String getLocker() { 792 return locker; 793 } 794 795 /** 796 * Sets the value of the locker property. 797 * 798 * @param value 799 * allowed object is 800 * {@link String } 801 * 802 */ 803 public void setLocker(String value) { 804 this.locker = value; 805 } 806 807 /** 808 * Gets the value of the maxAuditDepth property. 809 * 810 * @return 811 * possible object is 812 * {@link BigInteger } 813 * 814 */ 815 public BigInteger getMaxAuditDepth() { 816 return maxAuditDepth; 817 } 818 819 /** 820 * Sets the value of the maxAuditDepth property. 821 * 822 * @param value 823 * allowed object is 824 * {@link BigInteger } 825 * 826 */ 827 public void setMaxAuditDepth(BigInteger value) { 828 this.maxAuditDepth = value; 829 } 830 831 /** 832 * Gets the value of the maxProducersToAudit property. 833 * 834 * @return 835 * possible object is 836 * {@link BigInteger } 837 * 838 */ 839 public BigInteger getMaxProducersToAudit() { 840 return maxProducersToAudit; 841 } 842 843 /** 844 * Sets the value of the maxProducersToAudit property. 845 * 846 * @param value 847 * allowed object is 848 * {@link BigInteger } 849 * 850 */ 851 public void setMaxProducersToAudit(BigInteger value) { 852 this.maxProducersToAudit = value; 853 } 854 855 /** 856 * Gets the value of the maxRows property. 857 * 858 * @return 859 * possible object is 860 * {@link BigInteger } 861 * 862 */ 863 public BigInteger getMaxRows() { 864 return maxRows; 865 } 866 867 /** 868 * Sets the value of the maxRows property. 869 * 870 * @param value 871 * allowed object is 872 * {@link BigInteger } 873 * 874 */ 875 public void setMaxRows(BigInteger value) { 876 this.maxRows = value; 877 } 878 879 /** 880 * Gets the value of the scheduledThreadPoolExecutor property. 881 * 882 * @return 883 * possible object is 884 * {@link String } 885 * 886 */ 887 public String getScheduledThreadPoolExecutor() { 888 return scheduledThreadPoolExecutor; 889 } 890 891 /** 892 * Sets the value of the scheduledThreadPoolExecutor property. 893 * 894 * @param value 895 * allowed object is 896 * {@link String } 897 * 898 */ 899 public void setScheduledThreadPoolExecutor(String value) { 900 this.scheduledThreadPoolExecutor = value; 901 } 902 903 /** 904 * Gets the value of the statements property. 905 * 906 * @return 907 * possible object is 908 * {@link String } 909 * 910 */ 911 public String getStatements() { 912 return statements; 913 } 914 915 /** 916 * Sets the value of the statements property. 917 * 918 * @param value 919 * allowed object is 920 * {@link String } 921 * 922 */ 923 public void setStatements(String value) { 924 this.statements = value; 925 } 926 927 /** 928 * Gets the value of the transactionIsolation property. 929 * 930 * @return 931 * possible object is 932 * {@link BigInteger } 933 * 934 */ 935 public BigInteger getTransactionIsolation() { 936 return transactionIsolation; 937 } 938 939 /** 940 * Sets the value of the transactionIsolation property. 941 * 942 * @param value 943 * allowed object is 944 * {@link BigInteger } 945 * 946 */ 947 public void setTransactionIsolation(BigInteger value) { 948 this.transactionIsolation = value; 949 } 950 951 /** 952 * Gets the value of the usageManager property. 953 * 954 * @return 955 * possible object is 956 * {@link String } 957 * 958 */ 959 public String getUsageManager() { 960 return usageManager; 961 } 962 963 /** 964 * Sets the value of the usageManager property. 965 * 966 * @param value 967 * allowed object is 968 * {@link String } 969 * 970 */ 971 public void setUsageManager(String value) { 972 this.usageManager = value; 973 } 974 975 /** 976 * Gets the value of the useDatabaseLock property. 977 * 978 * @return 979 * possible object is 980 * {@link Boolean } 981 * 982 */ 983 public Boolean isUseDatabaseLock() { 984 return useDatabaseLock; 985 } 986 987 /** 988 * Sets the value of the useDatabaseLock property. 989 * 990 * @param value 991 * allowed object is 992 * {@link Boolean } 993 * 994 */ 995 public void setUseDatabaseLock(Boolean value) { 996 this.useDatabaseLock = value; 997 } 998 999 /** 1000 * Gets the value of the useExternalMessageReferences property. 1001 * 1002 * @return 1003 * possible object is 1004 * {@link Boolean } 1005 * 1006 */ 1007 public Boolean isUseExternalMessageReferences() { 1008 return useExternalMessageReferences; 1009 } 1010 1011 /** 1012 * Sets the value of the useExternalMessageReferences property. 1013 * 1014 * @param value 1015 * allowed object is 1016 * {@link Boolean } 1017 * 1018 */ 1019 public void setUseExternalMessageReferences(Boolean value) { 1020 this.useExternalMessageReferences = value; 1021 } 1022 1023 /** 1024 * Gets the value of the useLock property. 1025 * 1026 * @return 1027 * possible object is 1028 * {@link Boolean } 1029 * 1030 */ 1031 public Boolean isUseLock() { 1032 return useLock; 1033 } 1034 1035 /** 1036 * Sets the value of the useLock property. 1037 * 1038 * @param value 1039 * allowed object is 1040 * {@link Boolean } 1041 * 1042 */ 1043 public void setUseLock(Boolean value) { 1044 this.useLock = value; 1045 } 1046 1047 /** 1048 * Gets the value of the wireFormat property. 1049 * 1050 * @return 1051 * possible object is 1052 * {@link String } 1053 * 1054 */ 1055 public String getWireFormat() { 1056 return wireFormat; 1057 } 1058 1059 /** 1060 * Sets the value of the wireFormat property. 1061 * 1062 * @param value 1063 * allowed object is 1064 * {@link String } 1065 * 1066 */ 1067 public void setWireFormat(String value) { 1068 this.wireFormat = value; 1069 } 1070 1071 /** 1072 * Gets the value of the id property. 1073 * 1074 * @return 1075 * possible object is 1076 * {@link String } 1077 * 1078 */ 1079 public String getId() { 1080 return id; 1081 } 1082 1083 /** 1084 * Sets the value of the id property. 1085 * 1086 * @param value 1087 * allowed object is 1088 * {@link String } 1089 * 1090 */ 1091 public void setId(String value) { 1092 this.id = value; 1093 } 1094 1095 /** 1096 * Gets a map that contains attributes that aren't bound to any typed property on this class. 1097 * 1098 * <p> 1099 * the map is keyed by the name of the attribute and 1100 * the value is the string value of the attribute. 1101 * 1102 * the map returned by this method is live, and you can add new attribute 1103 * by updating the map directly. Because of this design, there's no setter. 1104 * 1105 * 1106 * @return 1107 * always non-null 1108 */ 1109 public Map<QName, String> getOtherAttributes() { 1110 return otherAttributes; 1111 } 1112 1113 public String toString() { 1114 final ToStringStrategy strategy = JAXBToStringStrategy.INSTANCE; 1115 final StringBuilder buffer = new StringBuilder(); 1116 append(null, buffer, strategy); 1117 return buffer.toString(); 1118 } 1119 1120 public StringBuilder append(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 1121 strategy.appendStart(locator, this, buffer); 1122 appendFields(locator, buffer, strategy); 1123 strategy.appendEnd(locator, this, buffer); 1124 return buffer; 1125 } 1126 1127 public StringBuilder appendFields(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 1128 { 1129 List<Object> theAdapterOrBrokerServiceOrDataSource; 1130 theAdapterOrBrokerServiceOrDataSource = (((this.adapterOrBrokerServiceOrDataSource!= null)&&(!this.adapterOrBrokerServiceOrDataSource.isEmpty()))?this.getAdapterOrBrokerServiceOrDataSource():null); 1131 strategy.appendField(locator, this, "adapterOrBrokerServiceOrDataSource", buffer, theAdapterOrBrokerServiceOrDataSource); 1132 } 1133 { 1134 String theAdapter; 1135 theAdapter = this.getAdapter(); 1136 strategy.appendField(locator, this, "adapter", buffer, theAdapter); 1137 } 1138 { 1139 BigInteger theAuditRecoveryDepth; 1140 theAuditRecoveryDepth = this.getAuditRecoveryDepth(); 1141 strategy.appendField(locator, this, "auditRecoveryDepth", buffer, theAuditRecoveryDepth); 1142 } 1143 { 1144 String theBrokerName; 1145 theBrokerName = this.getBrokerName(); 1146 strategy.appendField(locator, this, "brokerName", buffer, theBrokerName); 1147 } 1148 { 1149 String theBrokerService; 1150 theBrokerService = this.getBrokerService(); 1151 strategy.appendField(locator, this, "brokerService", buffer, theBrokerService); 1152 } 1153 { 1154 Boolean theChangeAutoCommitAllowed; 1155 theChangeAutoCommitAllowed = this.isChangeAutoCommitAllowed(); 1156 strategy.appendField(locator, this, "changeAutoCommitAllowed", buffer, theChangeAutoCommitAllowed); 1157 } 1158 { 1159 BigInteger theCleanupPeriod; 1160 theCleanupPeriod = this.getCleanupPeriod(); 1161 strategy.appendField(locator, this, "cleanupPeriod", buffer, theCleanupPeriod); 1162 } 1163 { 1164 Boolean theCreateTablesOnStartup; 1165 theCreateTablesOnStartup = this.isCreateTablesOnStartup(); 1166 strategy.appendField(locator, this, "createTablesOnStartup", buffer, theCreateTablesOnStartup); 1167 } 1168 { 1169 String theDataDirectory; 1170 theDataDirectory = this.getDataDirectory(); 1171 strategy.appendField(locator, this, "dataDirectory", buffer, theDataDirectory); 1172 } 1173 { 1174 String theDataDirectoryFile; 1175 theDataDirectoryFile = this.getDataDirectoryFile(); 1176 strategy.appendField(locator, this, "dataDirectoryFile", buffer, theDataDirectoryFile); 1177 } 1178 { 1179 String theDataSource; 1180 theDataSource = this.getDataSource(); 1181 strategy.appendField(locator, this, "dataSource", buffer, theDataSource); 1182 } 1183 { 1184 String theDatabaseLocker; 1185 theDatabaseLocker = this.getDatabaseLocker(); 1186 strategy.appendField(locator, this, "databaseLocker", buffer, theDatabaseLocker); 1187 } 1188 { 1189 String theDirectory; 1190 theDirectory = this.getDirectory(); 1191 strategy.appendField(locator, this, "directory", buffer, theDirectory); 1192 } 1193 { 1194 String theDs; 1195 theDs = this.getDs(); 1196 strategy.appendField(locator, this, "ds", buffer, theDs); 1197 } 1198 { 1199 Boolean theEnableAudit; 1200 theEnableAudit = this.isEnableAudit(); 1201 strategy.appendField(locator, this, "enableAudit", buffer, theEnableAudit); 1202 } 1203 { 1204 Long theLockAcquireSleepInterval; 1205 theLockAcquireSleepInterval = this.getLockAcquireSleepInterval(); 1206 strategy.appendField(locator, this, "lockAcquireSleepInterval", buffer, theLockAcquireSleepInterval); 1207 } 1208 { 1209 String theLockDataSource; 1210 theLockDataSource = this.getLockDataSource(); 1211 strategy.appendField(locator, this, "lockDataSource", buffer, theLockDataSource); 1212 } 1213 { 1214 Long theLockKeepAlivePeriod; 1215 theLockKeepAlivePeriod = this.getLockKeepAlivePeriod(); 1216 strategy.appendField(locator, this, "lockKeepAlivePeriod", buffer, theLockKeepAlivePeriod); 1217 } 1218 { 1219 String theLocker; 1220 theLocker = this.getLocker(); 1221 strategy.appendField(locator, this, "locker", buffer, theLocker); 1222 } 1223 { 1224 BigInteger theMaxAuditDepth; 1225 theMaxAuditDepth = this.getMaxAuditDepth(); 1226 strategy.appendField(locator, this, "maxAuditDepth", buffer, theMaxAuditDepth); 1227 } 1228 { 1229 BigInteger theMaxProducersToAudit; 1230 theMaxProducersToAudit = this.getMaxProducersToAudit(); 1231 strategy.appendField(locator, this, "maxProducersToAudit", buffer, theMaxProducersToAudit); 1232 } 1233 { 1234 BigInteger theMaxRows; 1235 theMaxRows = this.getMaxRows(); 1236 strategy.appendField(locator, this, "maxRows", buffer, theMaxRows); 1237 } 1238 { 1239 String theScheduledThreadPoolExecutor; 1240 theScheduledThreadPoolExecutor = this.getScheduledThreadPoolExecutor(); 1241 strategy.appendField(locator, this, "scheduledThreadPoolExecutor", buffer, theScheduledThreadPoolExecutor); 1242 } 1243 { 1244 String theStatements; 1245 theStatements = this.getStatements(); 1246 strategy.appendField(locator, this, "statements", buffer, theStatements); 1247 } 1248 { 1249 BigInteger theTransactionIsolation; 1250 theTransactionIsolation = this.getTransactionIsolation(); 1251 strategy.appendField(locator, this, "transactionIsolation", buffer, theTransactionIsolation); 1252 } 1253 { 1254 String theUsageManager; 1255 theUsageManager = this.getUsageManager(); 1256 strategy.appendField(locator, this, "usageManager", buffer, theUsageManager); 1257 } 1258 { 1259 Boolean theUseDatabaseLock; 1260 theUseDatabaseLock = this.isUseDatabaseLock(); 1261 strategy.appendField(locator, this, "useDatabaseLock", buffer, theUseDatabaseLock); 1262 } 1263 { 1264 Boolean theUseExternalMessageReferences; 1265 theUseExternalMessageReferences = this.isUseExternalMessageReferences(); 1266 strategy.appendField(locator, this, "useExternalMessageReferences", buffer, theUseExternalMessageReferences); 1267 } 1268 { 1269 Boolean theUseLock; 1270 theUseLock = this.isUseLock(); 1271 strategy.appendField(locator, this, "useLock", buffer, theUseLock); 1272 } 1273 { 1274 String theWireFormat; 1275 theWireFormat = this.getWireFormat(); 1276 strategy.appendField(locator, this, "wireFormat", buffer, theWireFormat); 1277 } 1278 { 1279 String theId; 1280 theId = this.getId(); 1281 strategy.appendField(locator, this, "id", buffer, theId); 1282 } 1283 return buffer; 1284 } 1285 1286 public int hashCode(ObjectLocator locator, HashCodeStrategy strategy) { 1287 int currentHashCode = 1; 1288 { 1289 List<Object> theAdapterOrBrokerServiceOrDataSource; 1290 theAdapterOrBrokerServiceOrDataSource = (((this.adapterOrBrokerServiceOrDataSource!= null)&&(!this.adapterOrBrokerServiceOrDataSource.isEmpty()))?this.getAdapterOrBrokerServiceOrDataSource():null); 1291 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "adapterOrBrokerServiceOrDataSource", theAdapterOrBrokerServiceOrDataSource), currentHashCode, theAdapterOrBrokerServiceOrDataSource); 1292 } 1293 { 1294 String theAdapter; 1295 theAdapter = this.getAdapter(); 1296 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "adapter", theAdapter), currentHashCode, theAdapter); 1297 } 1298 { 1299 BigInteger theAuditRecoveryDepth; 1300 theAuditRecoveryDepth = this.getAuditRecoveryDepth(); 1301 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "auditRecoveryDepth", theAuditRecoveryDepth), currentHashCode, theAuditRecoveryDepth); 1302 } 1303 { 1304 String theBrokerName; 1305 theBrokerName = this.getBrokerName(); 1306 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "brokerName", theBrokerName), currentHashCode, theBrokerName); 1307 } 1308 { 1309 String theBrokerService; 1310 theBrokerService = this.getBrokerService(); 1311 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "brokerService", theBrokerService), currentHashCode, theBrokerService); 1312 } 1313 { 1314 Boolean theChangeAutoCommitAllowed; 1315 theChangeAutoCommitAllowed = this.isChangeAutoCommitAllowed(); 1316 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "changeAutoCommitAllowed", theChangeAutoCommitAllowed), currentHashCode, theChangeAutoCommitAllowed); 1317 } 1318 { 1319 BigInteger theCleanupPeriod; 1320 theCleanupPeriod = this.getCleanupPeriod(); 1321 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "cleanupPeriod", theCleanupPeriod), currentHashCode, theCleanupPeriod); 1322 } 1323 { 1324 Boolean theCreateTablesOnStartup; 1325 theCreateTablesOnStartup = this.isCreateTablesOnStartup(); 1326 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "createTablesOnStartup", theCreateTablesOnStartup), currentHashCode, theCreateTablesOnStartup); 1327 } 1328 { 1329 String theDataDirectory; 1330 theDataDirectory = this.getDataDirectory(); 1331 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "dataDirectory", theDataDirectory), currentHashCode, theDataDirectory); 1332 } 1333 { 1334 String theDataDirectoryFile; 1335 theDataDirectoryFile = this.getDataDirectoryFile(); 1336 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "dataDirectoryFile", theDataDirectoryFile), currentHashCode, theDataDirectoryFile); 1337 } 1338 { 1339 String theDataSource; 1340 theDataSource = this.getDataSource(); 1341 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "dataSource", theDataSource), currentHashCode, theDataSource); 1342 } 1343 { 1344 String theDatabaseLocker; 1345 theDatabaseLocker = this.getDatabaseLocker(); 1346 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "databaseLocker", theDatabaseLocker), currentHashCode, theDatabaseLocker); 1347 } 1348 { 1349 String theDirectory; 1350 theDirectory = this.getDirectory(); 1351 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "directory", theDirectory), currentHashCode, theDirectory); 1352 } 1353 { 1354 String theDs; 1355 theDs = this.getDs(); 1356 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "ds", theDs), currentHashCode, theDs); 1357 } 1358 { 1359 Boolean theEnableAudit; 1360 theEnableAudit = this.isEnableAudit(); 1361 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "enableAudit", theEnableAudit), currentHashCode, theEnableAudit); 1362 } 1363 { 1364 Long theLockAcquireSleepInterval; 1365 theLockAcquireSleepInterval = this.getLockAcquireSleepInterval(); 1366 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "lockAcquireSleepInterval", theLockAcquireSleepInterval), currentHashCode, theLockAcquireSleepInterval); 1367 } 1368 { 1369 String theLockDataSource; 1370 theLockDataSource = this.getLockDataSource(); 1371 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "lockDataSource", theLockDataSource), currentHashCode, theLockDataSource); 1372 } 1373 { 1374 Long theLockKeepAlivePeriod; 1375 theLockKeepAlivePeriod = this.getLockKeepAlivePeriod(); 1376 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "lockKeepAlivePeriod", theLockKeepAlivePeriod), currentHashCode, theLockKeepAlivePeriod); 1377 } 1378 { 1379 String theLocker; 1380 theLocker = this.getLocker(); 1381 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "locker", theLocker), currentHashCode, theLocker); 1382 } 1383 { 1384 BigInteger theMaxAuditDepth; 1385 theMaxAuditDepth = this.getMaxAuditDepth(); 1386 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "maxAuditDepth", theMaxAuditDepth), currentHashCode, theMaxAuditDepth); 1387 } 1388 { 1389 BigInteger theMaxProducersToAudit; 1390 theMaxProducersToAudit = this.getMaxProducersToAudit(); 1391 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "maxProducersToAudit", theMaxProducersToAudit), currentHashCode, theMaxProducersToAudit); 1392 } 1393 { 1394 BigInteger theMaxRows; 1395 theMaxRows = this.getMaxRows(); 1396 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "maxRows", theMaxRows), currentHashCode, theMaxRows); 1397 } 1398 { 1399 String theScheduledThreadPoolExecutor; 1400 theScheduledThreadPoolExecutor = this.getScheduledThreadPoolExecutor(); 1401 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "scheduledThreadPoolExecutor", theScheduledThreadPoolExecutor), currentHashCode, theScheduledThreadPoolExecutor); 1402 } 1403 { 1404 String theStatements; 1405 theStatements = this.getStatements(); 1406 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "statements", theStatements), currentHashCode, theStatements); 1407 } 1408 { 1409 BigInteger theTransactionIsolation; 1410 theTransactionIsolation = this.getTransactionIsolation(); 1411 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "transactionIsolation", theTransactionIsolation), currentHashCode, theTransactionIsolation); 1412 } 1413 { 1414 String theUsageManager; 1415 theUsageManager = this.getUsageManager(); 1416 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "usageManager", theUsageManager), currentHashCode, theUsageManager); 1417 } 1418 { 1419 Boolean theUseDatabaseLock; 1420 theUseDatabaseLock = this.isUseDatabaseLock(); 1421 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "useDatabaseLock", theUseDatabaseLock), currentHashCode, theUseDatabaseLock); 1422 } 1423 { 1424 Boolean theUseExternalMessageReferences; 1425 theUseExternalMessageReferences = this.isUseExternalMessageReferences(); 1426 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "useExternalMessageReferences", theUseExternalMessageReferences), currentHashCode, theUseExternalMessageReferences); 1427 } 1428 { 1429 Boolean theUseLock; 1430 theUseLock = this.isUseLock(); 1431 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "useLock", theUseLock), currentHashCode, theUseLock); 1432 } 1433 { 1434 String theWireFormat; 1435 theWireFormat = this.getWireFormat(); 1436 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "wireFormat", theWireFormat), currentHashCode, theWireFormat); 1437 } 1438 { 1439 String theId; 1440 theId = this.getId(); 1441 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "id", theId), currentHashCode, theId); 1442 } 1443 return currentHashCode; 1444 } 1445 1446 public int hashCode() { 1447 final HashCodeStrategy strategy = JAXBHashCodeStrategy.INSTANCE; 1448 return this.hashCode(null, strategy); 1449 } 1450 1451 public boolean equals(ObjectLocator thisLocator, ObjectLocator thatLocator, Object object, EqualsStrategy strategy) { 1452 if (!(object instanceof DtoJdbcPersistenceAdapter)) { 1453 return false; 1454 } 1455 if (this == object) { 1456 return true; 1457 } 1458 final DtoJdbcPersistenceAdapter that = ((DtoJdbcPersistenceAdapter) object); 1459 { 1460 List<Object> lhsAdapterOrBrokerServiceOrDataSource; 1461 lhsAdapterOrBrokerServiceOrDataSource = (((this.adapterOrBrokerServiceOrDataSource!= null)&&(!this.adapterOrBrokerServiceOrDataSource.isEmpty()))?this.getAdapterOrBrokerServiceOrDataSource():null); 1462 List<Object> rhsAdapterOrBrokerServiceOrDataSource; 1463 rhsAdapterOrBrokerServiceOrDataSource = (((that.adapterOrBrokerServiceOrDataSource!= null)&&(!that.adapterOrBrokerServiceOrDataSource.isEmpty()))?that.getAdapterOrBrokerServiceOrDataSource():null); 1464 if (!strategy.equals(LocatorUtils.property(thisLocator, "adapterOrBrokerServiceOrDataSource", lhsAdapterOrBrokerServiceOrDataSource), LocatorUtils.property(thatLocator, "adapterOrBrokerServiceOrDataSource", rhsAdapterOrBrokerServiceOrDataSource), lhsAdapterOrBrokerServiceOrDataSource, rhsAdapterOrBrokerServiceOrDataSource)) { 1465 return false; 1466 } 1467 } 1468 { 1469 String lhsAdapter; 1470 lhsAdapter = this.getAdapter(); 1471 String rhsAdapter; 1472 rhsAdapter = that.getAdapter(); 1473 if (!strategy.equals(LocatorUtils.property(thisLocator, "adapter", lhsAdapter), LocatorUtils.property(thatLocator, "adapter", rhsAdapter), lhsAdapter, rhsAdapter)) { 1474 return false; 1475 } 1476 } 1477 { 1478 BigInteger lhsAuditRecoveryDepth; 1479 lhsAuditRecoveryDepth = this.getAuditRecoveryDepth(); 1480 BigInteger rhsAuditRecoveryDepth; 1481 rhsAuditRecoveryDepth = that.getAuditRecoveryDepth(); 1482 if (!strategy.equals(LocatorUtils.property(thisLocator, "auditRecoveryDepth", lhsAuditRecoveryDepth), LocatorUtils.property(thatLocator, "auditRecoveryDepth", rhsAuditRecoveryDepth), lhsAuditRecoveryDepth, rhsAuditRecoveryDepth)) { 1483 return false; 1484 } 1485 } 1486 { 1487 String lhsBrokerName; 1488 lhsBrokerName = this.getBrokerName(); 1489 String rhsBrokerName; 1490 rhsBrokerName = that.getBrokerName(); 1491 if (!strategy.equals(LocatorUtils.property(thisLocator, "brokerName", lhsBrokerName), LocatorUtils.property(thatLocator, "brokerName", rhsBrokerName), lhsBrokerName, rhsBrokerName)) { 1492 return false; 1493 } 1494 } 1495 { 1496 String lhsBrokerService; 1497 lhsBrokerService = this.getBrokerService(); 1498 String rhsBrokerService; 1499 rhsBrokerService = that.getBrokerService(); 1500 if (!strategy.equals(LocatorUtils.property(thisLocator, "brokerService", lhsBrokerService), LocatorUtils.property(thatLocator, "brokerService", rhsBrokerService), lhsBrokerService, rhsBrokerService)) { 1501 return false; 1502 } 1503 } 1504 { 1505 Boolean lhsChangeAutoCommitAllowed; 1506 lhsChangeAutoCommitAllowed = this.isChangeAutoCommitAllowed(); 1507 Boolean rhsChangeAutoCommitAllowed; 1508 rhsChangeAutoCommitAllowed = that.isChangeAutoCommitAllowed(); 1509 if (!strategy.equals(LocatorUtils.property(thisLocator, "changeAutoCommitAllowed", lhsChangeAutoCommitAllowed), LocatorUtils.property(thatLocator, "changeAutoCommitAllowed", rhsChangeAutoCommitAllowed), lhsChangeAutoCommitAllowed, rhsChangeAutoCommitAllowed)) { 1510 return false; 1511 } 1512 } 1513 { 1514 BigInteger lhsCleanupPeriod; 1515 lhsCleanupPeriod = this.getCleanupPeriod(); 1516 BigInteger rhsCleanupPeriod; 1517 rhsCleanupPeriod = that.getCleanupPeriod(); 1518 if (!strategy.equals(LocatorUtils.property(thisLocator, "cleanupPeriod", lhsCleanupPeriod), LocatorUtils.property(thatLocator, "cleanupPeriod", rhsCleanupPeriod), lhsCleanupPeriod, rhsCleanupPeriod)) { 1519 return false; 1520 } 1521 } 1522 { 1523 Boolean lhsCreateTablesOnStartup; 1524 lhsCreateTablesOnStartup = this.isCreateTablesOnStartup(); 1525 Boolean rhsCreateTablesOnStartup; 1526 rhsCreateTablesOnStartup = that.isCreateTablesOnStartup(); 1527 if (!strategy.equals(LocatorUtils.property(thisLocator, "createTablesOnStartup", lhsCreateTablesOnStartup), LocatorUtils.property(thatLocator, "createTablesOnStartup", rhsCreateTablesOnStartup), lhsCreateTablesOnStartup, rhsCreateTablesOnStartup)) { 1528 return false; 1529 } 1530 } 1531 { 1532 String lhsDataDirectory; 1533 lhsDataDirectory = this.getDataDirectory(); 1534 String rhsDataDirectory; 1535 rhsDataDirectory = that.getDataDirectory(); 1536 if (!strategy.equals(LocatorUtils.property(thisLocator, "dataDirectory", lhsDataDirectory), LocatorUtils.property(thatLocator, "dataDirectory", rhsDataDirectory), lhsDataDirectory, rhsDataDirectory)) { 1537 return false; 1538 } 1539 } 1540 { 1541 String lhsDataDirectoryFile; 1542 lhsDataDirectoryFile = this.getDataDirectoryFile(); 1543 String rhsDataDirectoryFile; 1544 rhsDataDirectoryFile = that.getDataDirectoryFile(); 1545 if (!strategy.equals(LocatorUtils.property(thisLocator, "dataDirectoryFile", lhsDataDirectoryFile), LocatorUtils.property(thatLocator, "dataDirectoryFile", rhsDataDirectoryFile), lhsDataDirectoryFile, rhsDataDirectoryFile)) { 1546 return false; 1547 } 1548 } 1549 { 1550 String lhsDataSource; 1551 lhsDataSource = this.getDataSource(); 1552 String rhsDataSource; 1553 rhsDataSource = that.getDataSource(); 1554 if (!strategy.equals(LocatorUtils.property(thisLocator, "dataSource", lhsDataSource), LocatorUtils.property(thatLocator, "dataSource", rhsDataSource), lhsDataSource, rhsDataSource)) { 1555 return false; 1556 } 1557 } 1558 { 1559 String lhsDatabaseLocker; 1560 lhsDatabaseLocker = this.getDatabaseLocker(); 1561 String rhsDatabaseLocker; 1562 rhsDatabaseLocker = that.getDatabaseLocker(); 1563 if (!strategy.equals(LocatorUtils.property(thisLocator, "databaseLocker", lhsDatabaseLocker), LocatorUtils.property(thatLocator, "databaseLocker", rhsDatabaseLocker), lhsDatabaseLocker, rhsDatabaseLocker)) { 1564 return false; 1565 } 1566 } 1567 { 1568 String lhsDirectory; 1569 lhsDirectory = this.getDirectory(); 1570 String rhsDirectory; 1571 rhsDirectory = that.getDirectory(); 1572 if (!strategy.equals(LocatorUtils.property(thisLocator, "directory", lhsDirectory), LocatorUtils.property(thatLocator, "directory", rhsDirectory), lhsDirectory, rhsDirectory)) { 1573 return false; 1574 } 1575 } 1576 { 1577 String lhsDs; 1578 lhsDs = this.getDs(); 1579 String rhsDs; 1580 rhsDs = that.getDs(); 1581 if (!strategy.equals(LocatorUtils.property(thisLocator, "ds", lhsDs), LocatorUtils.property(thatLocator, "ds", rhsDs), lhsDs, rhsDs)) { 1582 return false; 1583 } 1584 } 1585 { 1586 Boolean lhsEnableAudit; 1587 lhsEnableAudit = this.isEnableAudit(); 1588 Boolean rhsEnableAudit; 1589 rhsEnableAudit = that.isEnableAudit(); 1590 if (!strategy.equals(LocatorUtils.property(thisLocator, "enableAudit", lhsEnableAudit), LocatorUtils.property(thatLocator, "enableAudit", rhsEnableAudit), lhsEnableAudit, rhsEnableAudit)) { 1591 return false; 1592 } 1593 } 1594 { 1595 Long lhsLockAcquireSleepInterval; 1596 lhsLockAcquireSleepInterval = this.getLockAcquireSleepInterval(); 1597 Long rhsLockAcquireSleepInterval; 1598 rhsLockAcquireSleepInterval = that.getLockAcquireSleepInterval(); 1599 if (!strategy.equals(LocatorUtils.property(thisLocator, "lockAcquireSleepInterval", lhsLockAcquireSleepInterval), LocatorUtils.property(thatLocator, "lockAcquireSleepInterval", rhsLockAcquireSleepInterval), lhsLockAcquireSleepInterval, rhsLockAcquireSleepInterval)) { 1600 return false; 1601 } 1602 } 1603 { 1604 String lhsLockDataSource; 1605 lhsLockDataSource = this.getLockDataSource(); 1606 String rhsLockDataSource; 1607 rhsLockDataSource = that.getLockDataSource(); 1608 if (!strategy.equals(LocatorUtils.property(thisLocator, "lockDataSource", lhsLockDataSource), LocatorUtils.property(thatLocator, "lockDataSource", rhsLockDataSource), lhsLockDataSource, rhsLockDataSource)) { 1609 return false; 1610 } 1611 } 1612 { 1613 Long lhsLockKeepAlivePeriod; 1614 lhsLockKeepAlivePeriod = this.getLockKeepAlivePeriod(); 1615 Long rhsLockKeepAlivePeriod; 1616 rhsLockKeepAlivePeriod = that.getLockKeepAlivePeriod(); 1617 if (!strategy.equals(LocatorUtils.property(thisLocator, "lockKeepAlivePeriod", lhsLockKeepAlivePeriod), LocatorUtils.property(thatLocator, "lockKeepAlivePeriod", rhsLockKeepAlivePeriod), lhsLockKeepAlivePeriod, rhsLockKeepAlivePeriod)) { 1618 return false; 1619 } 1620 } 1621 { 1622 String lhsLocker; 1623 lhsLocker = this.getLocker(); 1624 String rhsLocker; 1625 rhsLocker = that.getLocker(); 1626 if (!strategy.equals(LocatorUtils.property(thisLocator, "locker", lhsLocker), LocatorUtils.property(thatLocator, "locker", rhsLocker), lhsLocker, rhsLocker)) { 1627 return false; 1628 } 1629 } 1630 { 1631 BigInteger lhsMaxAuditDepth; 1632 lhsMaxAuditDepth = this.getMaxAuditDepth(); 1633 BigInteger rhsMaxAuditDepth; 1634 rhsMaxAuditDepth = that.getMaxAuditDepth(); 1635 if (!strategy.equals(LocatorUtils.property(thisLocator, "maxAuditDepth", lhsMaxAuditDepth), LocatorUtils.property(thatLocator, "maxAuditDepth", rhsMaxAuditDepth), lhsMaxAuditDepth, rhsMaxAuditDepth)) { 1636 return false; 1637 } 1638 } 1639 { 1640 BigInteger lhsMaxProducersToAudit; 1641 lhsMaxProducersToAudit = this.getMaxProducersToAudit(); 1642 BigInteger rhsMaxProducersToAudit; 1643 rhsMaxProducersToAudit = that.getMaxProducersToAudit(); 1644 if (!strategy.equals(LocatorUtils.property(thisLocator, "maxProducersToAudit", lhsMaxProducersToAudit), LocatorUtils.property(thatLocator, "maxProducersToAudit", rhsMaxProducersToAudit), lhsMaxProducersToAudit, rhsMaxProducersToAudit)) { 1645 return false; 1646 } 1647 } 1648 { 1649 BigInteger lhsMaxRows; 1650 lhsMaxRows = this.getMaxRows(); 1651 BigInteger rhsMaxRows; 1652 rhsMaxRows = that.getMaxRows(); 1653 if (!strategy.equals(LocatorUtils.property(thisLocator, "maxRows", lhsMaxRows), LocatorUtils.property(thatLocator, "maxRows", rhsMaxRows), lhsMaxRows, rhsMaxRows)) { 1654 return false; 1655 } 1656 } 1657 { 1658 String lhsScheduledThreadPoolExecutor; 1659 lhsScheduledThreadPoolExecutor = this.getScheduledThreadPoolExecutor(); 1660 String rhsScheduledThreadPoolExecutor; 1661 rhsScheduledThreadPoolExecutor = that.getScheduledThreadPoolExecutor(); 1662 if (!strategy.equals(LocatorUtils.property(thisLocator, "scheduledThreadPoolExecutor", lhsScheduledThreadPoolExecutor), LocatorUtils.property(thatLocator, "scheduledThreadPoolExecutor", rhsScheduledThreadPoolExecutor), lhsScheduledThreadPoolExecutor, rhsScheduledThreadPoolExecutor)) { 1663 return false; 1664 } 1665 } 1666 { 1667 String lhsStatements; 1668 lhsStatements = this.getStatements(); 1669 String rhsStatements; 1670 rhsStatements = that.getStatements(); 1671 if (!strategy.equals(LocatorUtils.property(thisLocator, "statements", lhsStatements), LocatorUtils.property(thatLocator, "statements", rhsStatements), lhsStatements, rhsStatements)) { 1672 return false; 1673 } 1674 } 1675 { 1676 BigInteger lhsTransactionIsolation; 1677 lhsTransactionIsolation = this.getTransactionIsolation(); 1678 BigInteger rhsTransactionIsolation; 1679 rhsTransactionIsolation = that.getTransactionIsolation(); 1680 if (!strategy.equals(LocatorUtils.property(thisLocator, "transactionIsolation", lhsTransactionIsolation), LocatorUtils.property(thatLocator, "transactionIsolation", rhsTransactionIsolation), lhsTransactionIsolation, rhsTransactionIsolation)) { 1681 return false; 1682 } 1683 } 1684 { 1685 String lhsUsageManager; 1686 lhsUsageManager = this.getUsageManager(); 1687 String rhsUsageManager; 1688 rhsUsageManager = that.getUsageManager(); 1689 if (!strategy.equals(LocatorUtils.property(thisLocator, "usageManager", lhsUsageManager), LocatorUtils.property(thatLocator, "usageManager", rhsUsageManager), lhsUsageManager, rhsUsageManager)) { 1690 return false; 1691 } 1692 } 1693 { 1694 Boolean lhsUseDatabaseLock; 1695 lhsUseDatabaseLock = this.isUseDatabaseLock(); 1696 Boolean rhsUseDatabaseLock; 1697 rhsUseDatabaseLock = that.isUseDatabaseLock(); 1698 if (!strategy.equals(LocatorUtils.property(thisLocator, "useDatabaseLock", lhsUseDatabaseLock), LocatorUtils.property(thatLocator, "useDatabaseLock", rhsUseDatabaseLock), lhsUseDatabaseLock, rhsUseDatabaseLock)) { 1699 return false; 1700 } 1701 } 1702 { 1703 Boolean lhsUseExternalMessageReferences; 1704 lhsUseExternalMessageReferences = this.isUseExternalMessageReferences(); 1705 Boolean rhsUseExternalMessageReferences; 1706 rhsUseExternalMessageReferences = that.isUseExternalMessageReferences(); 1707 if (!strategy.equals(LocatorUtils.property(thisLocator, "useExternalMessageReferences", lhsUseExternalMessageReferences), LocatorUtils.property(thatLocator, "useExternalMessageReferences", rhsUseExternalMessageReferences), lhsUseExternalMessageReferences, rhsUseExternalMessageReferences)) { 1708 return false; 1709 } 1710 } 1711 { 1712 Boolean lhsUseLock; 1713 lhsUseLock = this.isUseLock(); 1714 Boolean rhsUseLock; 1715 rhsUseLock = that.isUseLock(); 1716 if (!strategy.equals(LocatorUtils.property(thisLocator, "useLock", lhsUseLock), LocatorUtils.property(thatLocator, "useLock", rhsUseLock), lhsUseLock, rhsUseLock)) { 1717 return false; 1718 } 1719 } 1720 { 1721 String lhsWireFormat; 1722 lhsWireFormat = this.getWireFormat(); 1723 String rhsWireFormat; 1724 rhsWireFormat = that.getWireFormat(); 1725 if (!strategy.equals(LocatorUtils.property(thisLocator, "wireFormat", lhsWireFormat), LocatorUtils.property(thatLocator, "wireFormat", rhsWireFormat), lhsWireFormat, rhsWireFormat)) { 1726 return false; 1727 } 1728 } 1729 { 1730 String lhsId; 1731 lhsId = this.getId(); 1732 String rhsId; 1733 rhsId = that.getId(); 1734 if (!strategy.equals(LocatorUtils.property(thisLocator, "id", lhsId), LocatorUtils.property(thatLocator, "id", rhsId), lhsId, rhsId)) { 1735 return false; 1736 } 1737 } 1738 return true; 1739 } 1740 1741 public boolean equals(Object object) { 1742 final EqualsStrategy strategy = new org.apache.activemq.plugin.jaxb2_commons.ElementAwareEqualsStrategy(); 1743 return equals(null, null, object, strategy); 1744 } 1745 1746 1747 /** 1748 * <p>Java class for anonymous complex type. 1749 * 1750 * <p>The following schema fragment specifies the expected content contained within this class. 1751 * 1752 * <pre> 1753 * <complexType> 1754 * <complexContent> 1755 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 1756 * <choice minOccurs="0"> 1757 * <element ref="{http://activemq.apache.org/schema/core}axionJDBCAdapter"/> 1758 * <element ref="{http://activemq.apache.org/schema/core}blobJDBCAdapter"/> 1759 * <element ref="{http://activemq.apache.org/schema/core}bytesJDBCAdapter"/> 1760 * <element ref="{http://activemq.apache.org/schema/core}db2JDBCAdapter"/> 1761 * <element ref="{http://activemq.apache.org/schema/core}defaultJDBCAdapter"/> 1762 * <element ref="{http://activemq.apache.org/schema/core}hsqldb-jdbc-adapter"/> 1763 * <element ref="{http://activemq.apache.org/schema/core}imageBasedJDBCAdaptor"/> 1764 * <element ref="{http://activemq.apache.org/schema/core}informixJDBCAdapter"/> 1765 * <element ref="{http://activemq.apache.org/schema/core}maxdb-jdbc-adapter"/> 1766 * <element ref="{http://activemq.apache.org/schema/core}mysql-jdbc-adapter"/> 1767 * <element ref="{http://activemq.apache.org/schema/core}oracleBlobJDBCAdapter"/> 1768 * <element ref="{http://activemq.apache.org/schema/core}oracleJDBCAdapter"/> 1769 * <element ref="{http://activemq.apache.org/schema/core}postgresql-jdbc-adapter"/> 1770 * <element ref="{http://activemq.apache.org/schema/core}sqlServerJDBCAdapter"/> 1771 * <element ref="{http://activemq.apache.org/schema/core}streamJDBCAdapter"/> 1772 * <element ref="{http://activemq.apache.org/schema/core}sybase-jdbc-adapter"/> 1773 * <element ref="{http://activemq.apache.org/schema/core}transact-jdbc-adapter"/> 1774 * <any namespace='##other'/> 1775 * </choice> 1776 * </restriction> 1777 * </complexContent> 1778 * </complexType> 1779 * </pre> 1780 * 1781 * 1782 */ 1783 @XmlAccessorType(XmlAccessType.FIELD) 1784 @XmlType(name = "", propOrder = { 1785 "axionJDBCAdapter", 1786 "blobJDBCAdapter", 1787 "bytesJDBCAdapter", 1788 "db2JDBCAdapter", 1789 "defaultJDBCAdapter", 1790 "hsqldbJdbcAdapter", 1791 "imageBasedJDBCAdaptor", 1792 "informixJDBCAdapter", 1793 "maxdbJdbcAdapter", 1794 "mysqlJdbcAdapter", 1795 "oracleBlobJDBCAdapter", 1796 "oracleJDBCAdapter", 1797 "postgresqlJdbcAdapter", 1798 "sqlServerJDBCAdapter", 1799 "streamJDBCAdapter", 1800 "sybaseJdbcAdapter", 1801 "transactJdbcAdapter", 1802 "any" 1803 }) 1804 public static class Adapter 1805 implements Equals, HashCode, ToString 1806 { 1807 1808 protected DtoAxionJDBCAdapter axionJDBCAdapter; 1809 protected DtoBlobJDBCAdapter blobJDBCAdapter; 1810 protected DtoBytesJDBCAdapter bytesJDBCAdapter; 1811 protected DtoDb2JDBCAdapter db2JDBCAdapter; 1812 protected DtoDefaultJDBCAdapter defaultJDBCAdapter; 1813 @XmlElement(name = "hsqldb-jdbc-adapter") 1814 protected DtoHsqldbJdbcAdapter hsqldbJdbcAdapter; 1815 protected DtoImageBasedJDBCAdaptor imageBasedJDBCAdaptor; 1816 protected DtoInformixJDBCAdapter informixJDBCAdapter; 1817 @XmlElement(name = "maxdb-jdbc-adapter") 1818 protected DtoMaxdbJdbcAdapter maxdbJdbcAdapter; 1819 @XmlElement(name = "mysql-jdbc-adapter") 1820 protected DtoMysqlJdbcAdapter mysqlJdbcAdapter; 1821 protected DtoOracleBlobJDBCAdapter oracleBlobJDBCAdapter; 1822 protected DtoOracleJDBCAdapter oracleJDBCAdapter; 1823 @XmlElement(name = "postgresql-jdbc-adapter") 1824 protected DtoPostgresqlJdbcAdapter postgresqlJdbcAdapter; 1825 protected DtoSqlServerJDBCAdapter sqlServerJDBCAdapter; 1826 protected DtoStreamJDBCAdapter streamJDBCAdapter; 1827 @XmlElement(name = "sybase-jdbc-adapter") 1828 protected DtoSybaseJdbcAdapter sybaseJdbcAdapter; 1829 @XmlElement(name = "transact-jdbc-adapter") 1830 protected DtoTransactJdbcAdapter transactJdbcAdapter; 1831 @XmlAnyElement(lax = true) 1832 protected Object any; 1833 1834 /** 1835 * Gets the value of the axionJDBCAdapter property. 1836 * 1837 * @return 1838 * possible object is 1839 * {@link DtoAxionJDBCAdapter } 1840 * 1841 */ 1842 public DtoAxionJDBCAdapter getAxionJDBCAdapter() { 1843 return axionJDBCAdapter; 1844 } 1845 1846 /** 1847 * Sets the value of the axionJDBCAdapter property. 1848 * 1849 * @param value 1850 * allowed object is 1851 * {@link DtoAxionJDBCAdapter } 1852 * 1853 */ 1854 public void setAxionJDBCAdapter(DtoAxionJDBCAdapter value) { 1855 this.axionJDBCAdapter = value; 1856 } 1857 1858 /** 1859 * Gets the value of the blobJDBCAdapter property. 1860 * 1861 * @return 1862 * possible object is 1863 * {@link DtoBlobJDBCAdapter } 1864 * 1865 */ 1866 public DtoBlobJDBCAdapter getBlobJDBCAdapter() { 1867 return blobJDBCAdapter; 1868 } 1869 1870 /** 1871 * Sets the value of the blobJDBCAdapter property. 1872 * 1873 * @param value 1874 * allowed object is 1875 * {@link DtoBlobJDBCAdapter } 1876 * 1877 */ 1878 public void setBlobJDBCAdapter(DtoBlobJDBCAdapter value) { 1879 this.blobJDBCAdapter = value; 1880 } 1881 1882 /** 1883 * Gets the value of the bytesJDBCAdapter property. 1884 * 1885 * @return 1886 * possible object is 1887 * {@link DtoBytesJDBCAdapter } 1888 * 1889 */ 1890 public DtoBytesJDBCAdapter getBytesJDBCAdapter() { 1891 return bytesJDBCAdapter; 1892 } 1893 1894 /** 1895 * Sets the value of the bytesJDBCAdapter property. 1896 * 1897 * @param value 1898 * allowed object is 1899 * {@link DtoBytesJDBCAdapter } 1900 * 1901 */ 1902 public void setBytesJDBCAdapter(DtoBytesJDBCAdapter value) { 1903 this.bytesJDBCAdapter = value; 1904 } 1905 1906 /** 1907 * Gets the value of the db2JDBCAdapter property. 1908 * 1909 * @return 1910 * possible object is 1911 * {@link DtoDb2JDBCAdapter } 1912 * 1913 */ 1914 public DtoDb2JDBCAdapter getDb2JDBCAdapter() { 1915 return db2JDBCAdapter; 1916 } 1917 1918 /** 1919 * Sets the value of the db2JDBCAdapter property. 1920 * 1921 * @param value 1922 * allowed object is 1923 * {@link DtoDb2JDBCAdapter } 1924 * 1925 */ 1926 public void setDb2JDBCAdapter(DtoDb2JDBCAdapter value) { 1927 this.db2JDBCAdapter = value; 1928 } 1929 1930 /** 1931 * Gets the value of the defaultJDBCAdapter property. 1932 * 1933 * @return 1934 * possible object is 1935 * {@link DtoDefaultJDBCAdapter } 1936 * 1937 */ 1938 public DtoDefaultJDBCAdapter getDefaultJDBCAdapter() { 1939 return defaultJDBCAdapter; 1940 } 1941 1942 /** 1943 * Sets the value of the defaultJDBCAdapter property. 1944 * 1945 * @param value 1946 * allowed object is 1947 * {@link DtoDefaultJDBCAdapter } 1948 * 1949 */ 1950 public void setDefaultJDBCAdapter(DtoDefaultJDBCAdapter value) { 1951 this.defaultJDBCAdapter = value; 1952 } 1953 1954 /** 1955 * Gets the value of the hsqldbJdbcAdapter property. 1956 * 1957 * @return 1958 * possible object is 1959 * {@link DtoHsqldbJdbcAdapter } 1960 * 1961 */ 1962 public DtoHsqldbJdbcAdapter getHsqldbJdbcAdapter() { 1963 return hsqldbJdbcAdapter; 1964 } 1965 1966 /** 1967 * Sets the value of the hsqldbJdbcAdapter property. 1968 * 1969 * @param value 1970 * allowed object is 1971 * {@link DtoHsqldbJdbcAdapter } 1972 * 1973 */ 1974 public void setHsqldbJdbcAdapter(DtoHsqldbJdbcAdapter value) { 1975 this.hsqldbJdbcAdapter = value; 1976 } 1977 1978 /** 1979 * Gets the value of the imageBasedJDBCAdaptor property. 1980 * 1981 * @return 1982 * possible object is 1983 * {@link DtoImageBasedJDBCAdaptor } 1984 * 1985 */ 1986 public DtoImageBasedJDBCAdaptor getImageBasedJDBCAdaptor() { 1987 return imageBasedJDBCAdaptor; 1988 } 1989 1990 /** 1991 * Sets the value of the imageBasedJDBCAdaptor property. 1992 * 1993 * @param value 1994 * allowed object is 1995 * {@link DtoImageBasedJDBCAdaptor } 1996 * 1997 */ 1998 public void setImageBasedJDBCAdaptor(DtoImageBasedJDBCAdaptor value) { 1999 this.imageBasedJDBCAdaptor = value; 2000 } 2001 2002 /** 2003 * Gets the value of the informixJDBCAdapter property. 2004 * 2005 * @return 2006 * possible object is 2007 * {@link DtoInformixJDBCAdapter } 2008 * 2009 */ 2010 public DtoInformixJDBCAdapter getInformixJDBCAdapter() { 2011 return informixJDBCAdapter; 2012 } 2013 2014 /** 2015 * Sets the value of the informixJDBCAdapter property. 2016 * 2017 * @param value 2018 * allowed object is 2019 * {@link DtoInformixJDBCAdapter } 2020 * 2021 */ 2022 public void setInformixJDBCAdapter(DtoInformixJDBCAdapter value) { 2023 this.informixJDBCAdapter = value; 2024 } 2025 2026 /** 2027 * Gets the value of the maxdbJdbcAdapter property. 2028 * 2029 * @return 2030 * possible object is 2031 * {@link DtoMaxdbJdbcAdapter } 2032 * 2033 */ 2034 public DtoMaxdbJdbcAdapter getMaxdbJdbcAdapter() { 2035 return maxdbJdbcAdapter; 2036 } 2037 2038 /** 2039 * Sets the value of the maxdbJdbcAdapter property. 2040 * 2041 * @param value 2042 * allowed object is 2043 * {@link DtoMaxdbJdbcAdapter } 2044 * 2045 */ 2046 public void setMaxdbJdbcAdapter(DtoMaxdbJdbcAdapter value) { 2047 this.maxdbJdbcAdapter = value; 2048 } 2049 2050 /** 2051 * Gets the value of the mysqlJdbcAdapter property. 2052 * 2053 * @return 2054 * possible object is 2055 * {@link DtoMysqlJdbcAdapter } 2056 * 2057 */ 2058 public DtoMysqlJdbcAdapter getMysqlJdbcAdapter() { 2059 return mysqlJdbcAdapter; 2060 } 2061 2062 /** 2063 * Sets the value of the mysqlJdbcAdapter property. 2064 * 2065 * @param value 2066 * allowed object is 2067 * {@link DtoMysqlJdbcAdapter } 2068 * 2069 */ 2070 public void setMysqlJdbcAdapter(DtoMysqlJdbcAdapter value) { 2071 this.mysqlJdbcAdapter = value; 2072 } 2073 2074 /** 2075 * Gets the value of the oracleBlobJDBCAdapter property. 2076 * 2077 * @return 2078 * possible object is 2079 * {@link DtoOracleBlobJDBCAdapter } 2080 * 2081 */ 2082 public DtoOracleBlobJDBCAdapter getOracleBlobJDBCAdapter() { 2083 return oracleBlobJDBCAdapter; 2084 } 2085 2086 /** 2087 * Sets the value of the oracleBlobJDBCAdapter property. 2088 * 2089 * @param value 2090 * allowed object is 2091 * {@link DtoOracleBlobJDBCAdapter } 2092 * 2093 */ 2094 public void setOracleBlobJDBCAdapter(DtoOracleBlobJDBCAdapter value) { 2095 this.oracleBlobJDBCAdapter = value; 2096 } 2097 2098 /** 2099 * Gets the value of the oracleJDBCAdapter property. 2100 * 2101 * @return 2102 * possible object is 2103 * {@link DtoOracleJDBCAdapter } 2104 * 2105 */ 2106 public DtoOracleJDBCAdapter getOracleJDBCAdapter() { 2107 return oracleJDBCAdapter; 2108 } 2109 2110 /** 2111 * Sets the value of the oracleJDBCAdapter property. 2112 * 2113 * @param value 2114 * allowed object is 2115 * {@link DtoOracleJDBCAdapter } 2116 * 2117 */ 2118 public void setOracleJDBCAdapter(DtoOracleJDBCAdapter value) { 2119 this.oracleJDBCAdapter = value; 2120 } 2121 2122 /** 2123 * Gets the value of the postgresqlJdbcAdapter property. 2124 * 2125 * @return 2126 * possible object is 2127 * {@link DtoPostgresqlJdbcAdapter } 2128 * 2129 */ 2130 public DtoPostgresqlJdbcAdapter getPostgresqlJdbcAdapter() { 2131 return postgresqlJdbcAdapter; 2132 } 2133 2134 /** 2135 * Sets the value of the postgresqlJdbcAdapter property. 2136 * 2137 * @param value 2138 * allowed object is 2139 * {@link DtoPostgresqlJdbcAdapter } 2140 * 2141 */ 2142 public void setPostgresqlJdbcAdapter(DtoPostgresqlJdbcAdapter value) { 2143 this.postgresqlJdbcAdapter = value; 2144 } 2145 2146 /** 2147 * Gets the value of the sqlServerJDBCAdapter property. 2148 * 2149 * @return 2150 * possible object is 2151 * {@link DtoSqlServerJDBCAdapter } 2152 * 2153 */ 2154 public DtoSqlServerJDBCAdapter getSqlServerJDBCAdapter() { 2155 return sqlServerJDBCAdapter; 2156 } 2157 2158 /** 2159 * Sets the value of the sqlServerJDBCAdapter property. 2160 * 2161 * @param value 2162 * allowed object is 2163 * {@link DtoSqlServerJDBCAdapter } 2164 * 2165 */ 2166 public void setSqlServerJDBCAdapter(DtoSqlServerJDBCAdapter value) { 2167 this.sqlServerJDBCAdapter = value; 2168 } 2169 2170 /** 2171 * Gets the value of the streamJDBCAdapter property. 2172 * 2173 * @return 2174 * possible object is 2175 * {@link DtoStreamJDBCAdapter } 2176 * 2177 */ 2178 public DtoStreamJDBCAdapter getStreamJDBCAdapter() { 2179 return streamJDBCAdapter; 2180 } 2181 2182 /** 2183 * Sets the value of the streamJDBCAdapter property. 2184 * 2185 * @param value 2186 * allowed object is 2187 * {@link DtoStreamJDBCAdapter } 2188 * 2189 */ 2190 public void setStreamJDBCAdapter(DtoStreamJDBCAdapter value) { 2191 this.streamJDBCAdapter = value; 2192 } 2193 2194 /** 2195 * Gets the value of the sybaseJdbcAdapter property. 2196 * 2197 * @return 2198 * possible object is 2199 * {@link DtoSybaseJdbcAdapter } 2200 * 2201 */ 2202 public DtoSybaseJdbcAdapter getSybaseJdbcAdapter() { 2203 return sybaseJdbcAdapter; 2204 } 2205 2206 /** 2207 * Sets the value of the sybaseJdbcAdapter property. 2208 * 2209 * @param value 2210 * allowed object is 2211 * {@link DtoSybaseJdbcAdapter } 2212 * 2213 */ 2214 public void setSybaseJdbcAdapter(DtoSybaseJdbcAdapter value) { 2215 this.sybaseJdbcAdapter = value; 2216 } 2217 2218 /** 2219 * Gets the value of the transactJdbcAdapter property. 2220 * 2221 * @return 2222 * possible object is 2223 * {@link DtoTransactJdbcAdapter } 2224 * 2225 */ 2226 public DtoTransactJdbcAdapter getTransactJdbcAdapter() { 2227 return transactJdbcAdapter; 2228 } 2229 2230 /** 2231 * Sets the value of the transactJdbcAdapter property. 2232 * 2233 * @param value 2234 * allowed object is 2235 * {@link DtoTransactJdbcAdapter } 2236 * 2237 */ 2238 public void setTransactJdbcAdapter(DtoTransactJdbcAdapter value) { 2239 this.transactJdbcAdapter = value; 2240 } 2241 2242 /** 2243 * Gets the value of the any property. 2244 * 2245 * @return 2246 * possible object is 2247 * {@link Object } 2248 * 2249 */ 2250 public Object getAny() { 2251 return any; 2252 } 2253 2254 /** 2255 * Sets the value of the any property. 2256 * 2257 * @param value 2258 * allowed object is 2259 * {@link Object } 2260 * 2261 */ 2262 public void setAny(Object value) { 2263 this.any = value; 2264 } 2265 2266 public String toString() { 2267 final ToStringStrategy strategy = JAXBToStringStrategy.INSTANCE; 2268 final StringBuilder buffer = new StringBuilder(); 2269 append(null, buffer, strategy); 2270 return buffer.toString(); 2271 } 2272 2273 public StringBuilder append(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 2274 strategy.appendStart(locator, this, buffer); 2275 appendFields(locator, buffer, strategy); 2276 strategy.appendEnd(locator, this, buffer); 2277 return buffer; 2278 } 2279 2280 public StringBuilder appendFields(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 2281 { 2282 DtoAxionJDBCAdapter theAxionJDBCAdapter; 2283 theAxionJDBCAdapter = this.getAxionJDBCAdapter(); 2284 strategy.appendField(locator, this, "axionJDBCAdapter", buffer, theAxionJDBCAdapter); 2285 } 2286 { 2287 DtoBlobJDBCAdapter theBlobJDBCAdapter; 2288 theBlobJDBCAdapter = this.getBlobJDBCAdapter(); 2289 strategy.appendField(locator, this, "blobJDBCAdapter", buffer, theBlobJDBCAdapter); 2290 } 2291 { 2292 DtoBytesJDBCAdapter theBytesJDBCAdapter; 2293 theBytesJDBCAdapter = this.getBytesJDBCAdapter(); 2294 strategy.appendField(locator, this, "bytesJDBCAdapter", buffer, theBytesJDBCAdapter); 2295 } 2296 { 2297 DtoDb2JDBCAdapter theDb2JDBCAdapter; 2298 theDb2JDBCAdapter = this.getDb2JDBCAdapter(); 2299 strategy.appendField(locator, this, "db2JDBCAdapter", buffer, theDb2JDBCAdapter); 2300 } 2301 { 2302 DtoDefaultJDBCAdapter theDefaultJDBCAdapter; 2303 theDefaultJDBCAdapter = this.getDefaultJDBCAdapter(); 2304 strategy.appendField(locator, this, "defaultJDBCAdapter", buffer, theDefaultJDBCAdapter); 2305 } 2306 { 2307 DtoHsqldbJdbcAdapter theHsqldbJdbcAdapter; 2308 theHsqldbJdbcAdapter = this.getHsqldbJdbcAdapter(); 2309 strategy.appendField(locator, this, "hsqldbJdbcAdapter", buffer, theHsqldbJdbcAdapter); 2310 } 2311 { 2312 DtoImageBasedJDBCAdaptor theImageBasedJDBCAdaptor; 2313 theImageBasedJDBCAdaptor = this.getImageBasedJDBCAdaptor(); 2314 strategy.appendField(locator, this, "imageBasedJDBCAdaptor", buffer, theImageBasedJDBCAdaptor); 2315 } 2316 { 2317 DtoInformixJDBCAdapter theInformixJDBCAdapter; 2318 theInformixJDBCAdapter = this.getInformixJDBCAdapter(); 2319 strategy.appendField(locator, this, "informixJDBCAdapter", buffer, theInformixJDBCAdapter); 2320 } 2321 { 2322 DtoMaxdbJdbcAdapter theMaxdbJdbcAdapter; 2323 theMaxdbJdbcAdapter = this.getMaxdbJdbcAdapter(); 2324 strategy.appendField(locator, this, "maxdbJdbcAdapter", buffer, theMaxdbJdbcAdapter); 2325 } 2326 { 2327 DtoMysqlJdbcAdapter theMysqlJdbcAdapter; 2328 theMysqlJdbcAdapter = this.getMysqlJdbcAdapter(); 2329 strategy.appendField(locator, this, "mysqlJdbcAdapter", buffer, theMysqlJdbcAdapter); 2330 } 2331 { 2332 DtoOracleBlobJDBCAdapter theOracleBlobJDBCAdapter; 2333 theOracleBlobJDBCAdapter = this.getOracleBlobJDBCAdapter(); 2334 strategy.appendField(locator, this, "oracleBlobJDBCAdapter", buffer, theOracleBlobJDBCAdapter); 2335 } 2336 { 2337 DtoOracleJDBCAdapter theOracleJDBCAdapter; 2338 theOracleJDBCAdapter = this.getOracleJDBCAdapter(); 2339 strategy.appendField(locator, this, "oracleJDBCAdapter", buffer, theOracleJDBCAdapter); 2340 } 2341 { 2342 DtoPostgresqlJdbcAdapter thePostgresqlJdbcAdapter; 2343 thePostgresqlJdbcAdapter = this.getPostgresqlJdbcAdapter(); 2344 strategy.appendField(locator, this, "postgresqlJdbcAdapter", buffer, thePostgresqlJdbcAdapter); 2345 } 2346 { 2347 DtoSqlServerJDBCAdapter theSqlServerJDBCAdapter; 2348 theSqlServerJDBCAdapter = this.getSqlServerJDBCAdapter(); 2349 strategy.appendField(locator, this, "sqlServerJDBCAdapter", buffer, theSqlServerJDBCAdapter); 2350 } 2351 { 2352 DtoStreamJDBCAdapter theStreamJDBCAdapter; 2353 theStreamJDBCAdapter = this.getStreamJDBCAdapter(); 2354 strategy.appendField(locator, this, "streamJDBCAdapter", buffer, theStreamJDBCAdapter); 2355 } 2356 { 2357 DtoSybaseJdbcAdapter theSybaseJdbcAdapter; 2358 theSybaseJdbcAdapter = this.getSybaseJdbcAdapter(); 2359 strategy.appendField(locator, this, "sybaseJdbcAdapter", buffer, theSybaseJdbcAdapter); 2360 } 2361 { 2362 DtoTransactJdbcAdapter theTransactJdbcAdapter; 2363 theTransactJdbcAdapter = this.getTransactJdbcAdapter(); 2364 strategy.appendField(locator, this, "transactJdbcAdapter", buffer, theTransactJdbcAdapter); 2365 } 2366 { 2367 Object theAny; 2368 theAny = this.getAny(); 2369 strategy.appendField(locator, this, "any", buffer, theAny); 2370 } 2371 return buffer; 2372 } 2373 2374 public int hashCode(ObjectLocator locator, HashCodeStrategy strategy) { 2375 int currentHashCode = 1; 2376 { 2377 DtoAxionJDBCAdapter theAxionJDBCAdapter; 2378 theAxionJDBCAdapter = this.getAxionJDBCAdapter(); 2379 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "axionJDBCAdapter", theAxionJDBCAdapter), currentHashCode, theAxionJDBCAdapter); 2380 } 2381 { 2382 DtoBlobJDBCAdapter theBlobJDBCAdapter; 2383 theBlobJDBCAdapter = this.getBlobJDBCAdapter(); 2384 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "blobJDBCAdapter", theBlobJDBCAdapter), currentHashCode, theBlobJDBCAdapter); 2385 } 2386 { 2387 DtoBytesJDBCAdapter theBytesJDBCAdapter; 2388 theBytesJDBCAdapter = this.getBytesJDBCAdapter(); 2389 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "bytesJDBCAdapter", theBytesJDBCAdapter), currentHashCode, theBytesJDBCAdapter); 2390 } 2391 { 2392 DtoDb2JDBCAdapter theDb2JDBCAdapter; 2393 theDb2JDBCAdapter = this.getDb2JDBCAdapter(); 2394 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "db2JDBCAdapter", theDb2JDBCAdapter), currentHashCode, theDb2JDBCAdapter); 2395 } 2396 { 2397 DtoDefaultJDBCAdapter theDefaultJDBCAdapter; 2398 theDefaultJDBCAdapter = this.getDefaultJDBCAdapter(); 2399 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "defaultJDBCAdapter", theDefaultJDBCAdapter), currentHashCode, theDefaultJDBCAdapter); 2400 } 2401 { 2402 DtoHsqldbJdbcAdapter theHsqldbJdbcAdapter; 2403 theHsqldbJdbcAdapter = this.getHsqldbJdbcAdapter(); 2404 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "hsqldbJdbcAdapter", theHsqldbJdbcAdapter), currentHashCode, theHsqldbJdbcAdapter); 2405 } 2406 { 2407 DtoImageBasedJDBCAdaptor theImageBasedJDBCAdaptor; 2408 theImageBasedJDBCAdaptor = this.getImageBasedJDBCAdaptor(); 2409 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "imageBasedJDBCAdaptor", theImageBasedJDBCAdaptor), currentHashCode, theImageBasedJDBCAdaptor); 2410 } 2411 { 2412 DtoInformixJDBCAdapter theInformixJDBCAdapter; 2413 theInformixJDBCAdapter = this.getInformixJDBCAdapter(); 2414 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "informixJDBCAdapter", theInformixJDBCAdapter), currentHashCode, theInformixJDBCAdapter); 2415 } 2416 { 2417 DtoMaxdbJdbcAdapter theMaxdbJdbcAdapter; 2418 theMaxdbJdbcAdapter = this.getMaxdbJdbcAdapter(); 2419 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "maxdbJdbcAdapter", theMaxdbJdbcAdapter), currentHashCode, theMaxdbJdbcAdapter); 2420 } 2421 { 2422 DtoMysqlJdbcAdapter theMysqlJdbcAdapter; 2423 theMysqlJdbcAdapter = this.getMysqlJdbcAdapter(); 2424 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "mysqlJdbcAdapter", theMysqlJdbcAdapter), currentHashCode, theMysqlJdbcAdapter); 2425 } 2426 { 2427 DtoOracleBlobJDBCAdapter theOracleBlobJDBCAdapter; 2428 theOracleBlobJDBCAdapter = this.getOracleBlobJDBCAdapter(); 2429 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "oracleBlobJDBCAdapter", theOracleBlobJDBCAdapter), currentHashCode, theOracleBlobJDBCAdapter); 2430 } 2431 { 2432 DtoOracleJDBCAdapter theOracleJDBCAdapter; 2433 theOracleJDBCAdapter = this.getOracleJDBCAdapter(); 2434 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "oracleJDBCAdapter", theOracleJDBCAdapter), currentHashCode, theOracleJDBCAdapter); 2435 } 2436 { 2437 DtoPostgresqlJdbcAdapter thePostgresqlJdbcAdapter; 2438 thePostgresqlJdbcAdapter = this.getPostgresqlJdbcAdapter(); 2439 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "postgresqlJdbcAdapter", thePostgresqlJdbcAdapter), currentHashCode, thePostgresqlJdbcAdapter); 2440 } 2441 { 2442 DtoSqlServerJDBCAdapter theSqlServerJDBCAdapter; 2443 theSqlServerJDBCAdapter = this.getSqlServerJDBCAdapter(); 2444 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "sqlServerJDBCAdapter", theSqlServerJDBCAdapter), currentHashCode, theSqlServerJDBCAdapter); 2445 } 2446 { 2447 DtoStreamJDBCAdapter theStreamJDBCAdapter; 2448 theStreamJDBCAdapter = this.getStreamJDBCAdapter(); 2449 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "streamJDBCAdapter", theStreamJDBCAdapter), currentHashCode, theStreamJDBCAdapter); 2450 } 2451 { 2452 DtoSybaseJdbcAdapter theSybaseJdbcAdapter; 2453 theSybaseJdbcAdapter = this.getSybaseJdbcAdapter(); 2454 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "sybaseJdbcAdapter", theSybaseJdbcAdapter), currentHashCode, theSybaseJdbcAdapter); 2455 } 2456 { 2457 DtoTransactJdbcAdapter theTransactJdbcAdapter; 2458 theTransactJdbcAdapter = this.getTransactJdbcAdapter(); 2459 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "transactJdbcAdapter", theTransactJdbcAdapter), currentHashCode, theTransactJdbcAdapter); 2460 } 2461 { 2462 Object theAny; 2463 theAny = this.getAny(); 2464 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "any", theAny), currentHashCode, theAny); 2465 } 2466 return currentHashCode; 2467 } 2468 2469 public int hashCode() { 2470 final HashCodeStrategy strategy = JAXBHashCodeStrategy.INSTANCE; 2471 return this.hashCode(null, strategy); 2472 } 2473 2474 public boolean equals(ObjectLocator thisLocator, ObjectLocator thatLocator, Object object, EqualsStrategy strategy) { 2475 if (!(object instanceof DtoJdbcPersistenceAdapter.Adapter)) { 2476 return false; 2477 } 2478 if (this == object) { 2479 return true; 2480 } 2481 final DtoJdbcPersistenceAdapter.Adapter that = ((DtoJdbcPersistenceAdapter.Adapter) object); 2482 { 2483 DtoAxionJDBCAdapter lhsAxionJDBCAdapter; 2484 lhsAxionJDBCAdapter = this.getAxionJDBCAdapter(); 2485 DtoAxionJDBCAdapter rhsAxionJDBCAdapter; 2486 rhsAxionJDBCAdapter = that.getAxionJDBCAdapter(); 2487 if (!strategy.equals(LocatorUtils.property(thisLocator, "axionJDBCAdapter", lhsAxionJDBCAdapter), LocatorUtils.property(thatLocator, "axionJDBCAdapter", rhsAxionJDBCAdapter), lhsAxionJDBCAdapter, rhsAxionJDBCAdapter)) { 2488 return false; 2489 } 2490 } 2491 { 2492 DtoBlobJDBCAdapter lhsBlobJDBCAdapter; 2493 lhsBlobJDBCAdapter = this.getBlobJDBCAdapter(); 2494 DtoBlobJDBCAdapter rhsBlobJDBCAdapter; 2495 rhsBlobJDBCAdapter = that.getBlobJDBCAdapter(); 2496 if (!strategy.equals(LocatorUtils.property(thisLocator, "blobJDBCAdapter", lhsBlobJDBCAdapter), LocatorUtils.property(thatLocator, "blobJDBCAdapter", rhsBlobJDBCAdapter), lhsBlobJDBCAdapter, rhsBlobJDBCAdapter)) { 2497 return false; 2498 } 2499 } 2500 { 2501 DtoBytesJDBCAdapter lhsBytesJDBCAdapter; 2502 lhsBytesJDBCAdapter = this.getBytesJDBCAdapter(); 2503 DtoBytesJDBCAdapter rhsBytesJDBCAdapter; 2504 rhsBytesJDBCAdapter = that.getBytesJDBCAdapter(); 2505 if (!strategy.equals(LocatorUtils.property(thisLocator, "bytesJDBCAdapter", lhsBytesJDBCAdapter), LocatorUtils.property(thatLocator, "bytesJDBCAdapter", rhsBytesJDBCAdapter), lhsBytesJDBCAdapter, rhsBytesJDBCAdapter)) { 2506 return false; 2507 } 2508 } 2509 { 2510 DtoDb2JDBCAdapter lhsDb2JDBCAdapter; 2511 lhsDb2JDBCAdapter = this.getDb2JDBCAdapter(); 2512 DtoDb2JDBCAdapter rhsDb2JDBCAdapter; 2513 rhsDb2JDBCAdapter = that.getDb2JDBCAdapter(); 2514 if (!strategy.equals(LocatorUtils.property(thisLocator, "db2JDBCAdapter", lhsDb2JDBCAdapter), LocatorUtils.property(thatLocator, "db2JDBCAdapter", rhsDb2JDBCAdapter), lhsDb2JDBCAdapter, rhsDb2JDBCAdapter)) { 2515 return false; 2516 } 2517 } 2518 { 2519 DtoDefaultJDBCAdapter lhsDefaultJDBCAdapter; 2520 lhsDefaultJDBCAdapter = this.getDefaultJDBCAdapter(); 2521 DtoDefaultJDBCAdapter rhsDefaultJDBCAdapter; 2522 rhsDefaultJDBCAdapter = that.getDefaultJDBCAdapter(); 2523 if (!strategy.equals(LocatorUtils.property(thisLocator, "defaultJDBCAdapter", lhsDefaultJDBCAdapter), LocatorUtils.property(thatLocator, "defaultJDBCAdapter", rhsDefaultJDBCAdapter), lhsDefaultJDBCAdapter, rhsDefaultJDBCAdapter)) { 2524 return false; 2525 } 2526 } 2527 { 2528 DtoHsqldbJdbcAdapter lhsHsqldbJdbcAdapter; 2529 lhsHsqldbJdbcAdapter = this.getHsqldbJdbcAdapter(); 2530 DtoHsqldbJdbcAdapter rhsHsqldbJdbcAdapter; 2531 rhsHsqldbJdbcAdapter = that.getHsqldbJdbcAdapter(); 2532 if (!strategy.equals(LocatorUtils.property(thisLocator, "hsqldbJdbcAdapter", lhsHsqldbJdbcAdapter), LocatorUtils.property(thatLocator, "hsqldbJdbcAdapter", rhsHsqldbJdbcAdapter), lhsHsqldbJdbcAdapter, rhsHsqldbJdbcAdapter)) { 2533 return false; 2534 } 2535 } 2536 { 2537 DtoImageBasedJDBCAdaptor lhsImageBasedJDBCAdaptor; 2538 lhsImageBasedJDBCAdaptor = this.getImageBasedJDBCAdaptor(); 2539 DtoImageBasedJDBCAdaptor rhsImageBasedJDBCAdaptor; 2540 rhsImageBasedJDBCAdaptor = that.getImageBasedJDBCAdaptor(); 2541 if (!strategy.equals(LocatorUtils.property(thisLocator, "imageBasedJDBCAdaptor", lhsImageBasedJDBCAdaptor), LocatorUtils.property(thatLocator, "imageBasedJDBCAdaptor", rhsImageBasedJDBCAdaptor), lhsImageBasedJDBCAdaptor, rhsImageBasedJDBCAdaptor)) { 2542 return false; 2543 } 2544 } 2545 { 2546 DtoInformixJDBCAdapter lhsInformixJDBCAdapter; 2547 lhsInformixJDBCAdapter = this.getInformixJDBCAdapter(); 2548 DtoInformixJDBCAdapter rhsInformixJDBCAdapter; 2549 rhsInformixJDBCAdapter = that.getInformixJDBCAdapter(); 2550 if (!strategy.equals(LocatorUtils.property(thisLocator, "informixJDBCAdapter", lhsInformixJDBCAdapter), LocatorUtils.property(thatLocator, "informixJDBCAdapter", rhsInformixJDBCAdapter), lhsInformixJDBCAdapter, rhsInformixJDBCAdapter)) { 2551 return false; 2552 } 2553 } 2554 { 2555 DtoMaxdbJdbcAdapter lhsMaxdbJdbcAdapter; 2556 lhsMaxdbJdbcAdapter = this.getMaxdbJdbcAdapter(); 2557 DtoMaxdbJdbcAdapter rhsMaxdbJdbcAdapter; 2558 rhsMaxdbJdbcAdapter = that.getMaxdbJdbcAdapter(); 2559 if (!strategy.equals(LocatorUtils.property(thisLocator, "maxdbJdbcAdapter", lhsMaxdbJdbcAdapter), LocatorUtils.property(thatLocator, "maxdbJdbcAdapter", rhsMaxdbJdbcAdapter), lhsMaxdbJdbcAdapter, rhsMaxdbJdbcAdapter)) { 2560 return false; 2561 } 2562 } 2563 { 2564 DtoMysqlJdbcAdapter lhsMysqlJdbcAdapter; 2565 lhsMysqlJdbcAdapter = this.getMysqlJdbcAdapter(); 2566 DtoMysqlJdbcAdapter rhsMysqlJdbcAdapter; 2567 rhsMysqlJdbcAdapter = that.getMysqlJdbcAdapter(); 2568 if (!strategy.equals(LocatorUtils.property(thisLocator, "mysqlJdbcAdapter", lhsMysqlJdbcAdapter), LocatorUtils.property(thatLocator, "mysqlJdbcAdapter", rhsMysqlJdbcAdapter), lhsMysqlJdbcAdapter, rhsMysqlJdbcAdapter)) { 2569 return false; 2570 } 2571 } 2572 { 2573 DtoOracleBlobJDBCAdapter lhsOracleBlobJDBCAdapter; 2574 lhsOracleBlobJDBCAdapter = this.getOracleBlobJDBCAdapter(); 2575 DtoOracleBlobJDBCAdapter rhsOracleBlobJDBCAdapter; 2576 rhsOracleBlobJDBCAdapter = that.getOracleBlobJDBCAdapter(); 2577 if (!strategy.equals(LocatorUtils.property(thisLocator, "oracleBlobJDBCAdapter", lhsOracleBlobJDBCAdapter), LocatorUtils.property(thatLocator, "oracleBlobJDBCAdapter", rhsOracleBlobJDBCAdapter), lhsOracleBlobJDBCAdapter, rhsOracleBlobJDBCAdapter)) { 2578 return false; 2579 } 2580 } 2581 { 2582 DtoOracleJDBCAdapter lhsOracleJDBCAdapter; 2583 lhsOracleJDBCAdapter = this.getOracleJDBCAdapter(); 2584 DtoOracleJDBCAdapter rhsOracleJDBCAdapter; 2585 rhsOracleJDBCAdapter = that.getOracleJDBCAdapter(); 2586 if (!strategy.equals(LocatorUtils.property(thisLocator, "oracleJDBCAdapter", lhsOracleJDBCAdapter), LocatorUtils.property(thatLocator, "oracleJDBCAdapter", rhsOracleJDBCAdapter), lhsOracleJDBCAdapter, rhsOracleJDBCAdapter)) { 2587 return false; 2588 } 2589 } 2590 { 2591 DtoPostgresqlJdbcAdapter lhsPostgresqlJdbcAdapter; 2592 lhsPostgresqlJdbcAdapter = this.getPostgresqlJdbcAdapter(); 2593 DtoPostgresqlJdbcAdapter rhsPostgresqlJdbcAdapter; 2594 rhsPostgresqlJdbcAdapter = that.getPostgresqlJdbcAdapter(); 2595 if (!strategy.equals(LocatorUtils.property(thisLocator, "postgresqlJdbcAdapter", lhsPostgresqlJdbcAdapter), LocatorUtils.property(thatLocator, "postgresqlJdbcAdapter", rhsPostgresqlJdbcAdapter), lhsPostgresqlJdbcAdapter, rhsPostgresqlJdbcAdapter)) { 2596 return false; 2597 } 2598 } 2599 { 2600 DtoSqlServerJDBCAdapter lhsSqlServerJDBCAdapter; 2601 lhsSqlServerJDBCAdapter = this.getSqlServerJDBCAdapter(); 2602 DtoSqlServerJDBCAdapter rhsSqlServerJDBCAdapter; 2603 rhsSqlServerJDBCAdapter = that.getSqlServerJDBCAdapter(); 2604 if (!strategy.equals(LocatorUtils.property(thisLocator, "sqlServerJDBCAdapter", lhsSqlServerJDBCAdapter), LocatorUtils.property(thatLocator, "sqlServerJDBCAdapter", rhsSqlServerJDBCAdapter), lhsSqlServerJDBCAdapter, rhsSqlServerJDBCAdapter)) { 2605 return false; 2606 } 2607 } 2608 { 2609 DtoStreamJDBCAdapter lhsStreamJDBCAdapter; 2610 lhsStreamJDBCAdapter = this.getStreamJDBCAdapter(); 2611 DtoStreamJDBCAdapter rhsStreamJDBCAdapter; 2612 rhsStreamJDBCAdapter = that.getStreamJDBCAdapter(); 2613 if (!strategy.equals(LocatorUtils.property(thisLocator, "streamJDBCAdapter", lhsStreamJDBCAdapter), LocatorUtils.property(thatLocator, "streamJDBCAdapter", rhsStreamJDBCAdapter), lhsStreamJDBCAdapter, rhsStreamJDBCAdapter)) { 2614 return false; 2615 } 2616 } 2617 { 2618 DtoSybaseJdbcAdapter lhsSybaseJdbcAdapter; 2619 lhsSybaseJdbcAdapter = this.getSybaseJdbcAdapter(); 2620 DtoSybaseJdbcAdapter rhsSybaseJdbcAdapter; 2621 rhsSybaseJdbcAdapter = that.getSybaseJdbcAdapter(); 2622 if (!strategy.equals(LocatorUtils.property(thisLocator, "sybaseJdbcAdapter", lhsSybaseJdbcAdapter), LocatorUtils.property(thatLocator, "sybaseJdbcAdapter", rhsSybaseJdbcAdapter), lhsSybaseJdbcAdapter, rhsSybaseJdbcAdapter)) { 2623 return false; 2624 } 2625 } 2626 { 2627 DtoTransactJdbcAdapter lhsTransactJdbcAdapter; 2628 lhsTransactJdbcAdapter = this.getTransactJdbcAdapter(); 2629 DtoTransactJdbcAdapter rhsTransactJdbcAdapter; 2630 rhsTransactJdbcAdapter = that.getTransactJdbcAdapter(); 2631 if (!strategy.equals(LocatorUtils.property(thisLocator, "transactJdbcAdapter", lhsTransactJdbcAdapter), LocatorUtils.property(thatLocator, "transactJdbcAdapter", rhsTransactJdbcAdapter), lhsTransactJdbcAdapter, rhsTransactJdbcAdapter)) { 2632 return false; 2633 } 2634 } 2635 { 2636 Object lhsAny; 2637 lhsAny = this.getAny(); 2638 Object rhsAny; 2639 rhsAny = that.getAny(); 2640 if (!strategy.equals(LocatorUtils.property(thisLocator, "any", lhsAny), LocatorUtils.property(thatLocator, "any", rhsAny), lhsAny, rhsAny)) { 2641 return false; 2642 } 2643 } 2644 return true; 2645 } 2646 2647 public boolean equals(Object object) { 2648 final EqualsStrategy strategy = new org.apache.activemq.plugin.jaxb2_commons.ElementAwareEqualsStrategy(); 2649 return equals(null, null, object, strategy); 2650 } 2651 2652 } 2653 2654 2655 /** 2656 * <p>Java class for anonymous complex type. 2657 * 2658 * <p>The following schema fragment specifies the expected content contained within this class. 2659 * 2660 * <pre> 2661 * <complexType> 2662 * <complexContent> 2663 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 2664 * <choice minOccurs="0"> 2665 * <element ref="{http://activemq.apache.org/schema/core}broker"/> 2666 * <element ref="{http://activemq.apache.org/schema/core}brokerService"/> 2667 * <any namespace='##other'/> 2668 * </choice> 2669 * </restriction> 2670 * </complexContent> 2671 * </complexType> 2672 * </pre> 2673 * 2674 * 2675 */ 2676 @XmlAccessorType(XmlAccessType.FIELD) 2677 @XmlType(name = "", propOrder = { 2678 "broker", 2679 "brokerService", 2680 "any" 2681 }) 2682 public static class BrokerService 2683 implements Equals, HashCode, ToString 2684 { 2685 2686 protected DtoBroker broker; 2687 protected DtoBrokerService brokerService; 2688 @XmlAnyElement(lax = true) 2689 protected Object any; 2690 2691 /** 2692 * Gets the value of the broker property. 2693 * 2694 * @return 2695 * possible object is 2696 * {@link DtoBroker } 2697 * 2698 */ 2699 public DtoBroker getBroker() { 2700 return broker; 2701 } 2702 2703 /** 2704 * Sets the value of the broker property. 2705 * 2706 * @param value 2707 * allowed object is 2708 * {@link DtoBroker } 2709 * 2710 */ 2711 public void setBroker(DtoBroker value) { 2712 this.broker = value; 2713 } 2714 2715 /** 2716 * Gets the value of the brokerService property. 2717 * 2718 * @return 2719 * possible object is 2720 * {@link DtoBrokerService } 2721 * 2722 */ 2723 public DtoBrokerService getBrokerService() { 2724 return brokerService; 2725 } 2726 2727 /** 2728 * Sets the value of the brokerService property. 2729 * 2730 * @param value 2731 * allowed object is 2732 * {@link DtoBrokerService } 2733 * 2734 */ 2735 public void setBrokerService(DtoBrokerService value) { 2736 this.brokerService = value; 2737 } 2738 2739 /** 2740 * Gets the value of the any property. 2741 * 2742 * @return 2743 * possible object is 2744 * {@link Object } 2745 * 2746 */ 2747 public Object getAny() { 2748 return any; 2749 } 2750 2751 /** 2752 * Sets the value of the any property. 2753 * 2754 * @param value 2755 * allowed object is 2756 * {@link Object } 2757 * 2758 */ 2759 public void setAny(Object value) { 2760 this.any = value; 2761 } 2762 2763 public String toString() { 2764 final ToStringStrategy strategy = JAXBToStringStrategy.INSTANCE; 2765 final StringBuilder buffer = new StringBuilder(); 2766 append(null, buffer, strategy); 2767 return buffer.toString(); 2768 } 2769 2770 public StringBuilder append(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 2771 strategy.appendStart(locator, this, buffer); 2772 appendFields(locator, buffer, strategy); 2773 strategy.appendEnd(locator, this, buffer); 2774 return buffer; 2775 } 2776 2777 public StringBuilder appendFields(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 2778 { 2779 DtoBroker theBroker; 2780 theBroker = this.getBroker(); 2781 strategy.appendField(locator, this, "broker", buffer, theBroker); 2782 } 2783 { 2784 DtoBrokerService theBrokerService; 2785 theBrokerService = this.getBrokerService(); 2786 strategy.appendField(locator, this, "brokerService", buffer, theBrokerService); 2787 } 2788 { 2789 Object theAny; 2790 theAny = this.getAny(); 2791 strategy.appendField(locator, this, "any", buffer, theAny); 2792 } 2793 return buffer; 2794 } 2795 2796 public int hashCode(ObjectLocator locator, HashCodeStrategy strategy) { 2797 int currentHashCode = 1; 2798 { 2799 DtoBroker theBroker; 2800 theBroker = this.getBroker(); 2801 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "broker", theBroker), currentHashCode, theBroker); 2802 } 2803 { 2804 DtoBrokerService theBrokerService; 2805 theBrokerService = this.getBrokerService(); 2806 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "brokerService", theBrokerService), currentHashCode, theBrokerService); 2807 } 2808 { 2809 Object theAny; 2810 theAny = this.getAny(); 2811 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "any", theAny), currentHashCode, theAny); 2812 } 2813 return currentHashCode; 2814 } 2815 2816 public int hashCode() { 2817 final HashCodeStrategy strategy = JAXBHashCodeStrategy.INSTANCE; 2818 return this.hashCode(null, strategy); 2819 } 2820 2821 public boolean equals(ObjectLocator thisLocator, ObjectLocator thatLocator, Object object, EqualsStrategy strategy) { 2822 if (!(object instanceof DtoJdbcPersistenceAdapter.BrokerService)) { 2823 return false; 2824 } 2825 if (this == object) { 2826 return true; 2827 } 2828 final DtoJdbcPersistenceAdapter.BrokerService that = ((DtoJdbcPersistenceAdapter.BrokerService) object); 2829 { 2830 DtoBroker lhsBroker; 2831 lhsBroker = this.getBroker(); 2832 DtoBroker rhsBroker; 2833 rhsBroker = that.getBroker(); 2834 if (!strategy.equals(LocatorUtils.property(thisLocator, "broker", lhsBroker), LocatorUtils.property(thatLocator, "broker", rhsBroker), lhsBroker, rhsBroker)) { 2835 return false; 2836 } 2837 } 2838 { 2839 DtoBrokerService lhsBrokerService; 2840 lhsBrokerService = this.getBrokerService(); 2841 DtoBrokerService rhsBrokerService; 2842 rhsBrokerService = that.getBrokerService(); 2843 if (!strategy.equals(LocatorUtils.property(thisLocator, "brokerService", lhsBrokerService), LocatorUtils.property(thatLocator, "brokerService", rhsBrokerService), lhsBrokerService, rhsBrokerService)) { 2844 return false; 2845 } 2846 } 2847 { 2848 Object lhsAny; 2849 lhsAny = this.getAny(); 2850 Object rhsAny; 2851 rhsAny = that.getAny(); 2852 if (!strategy.equals(LocatorUtils.property(thisLocator, "any", lhsAny), LocatorUtils.property(thatLocator, "any", rhsAny), lhsAny, rhsAny)) { 2853 return false; 2854 } 2855 } 2856 return true; 2857 } 2858 2859 public boolean equals(Object object) { 2860 final EqualsStrategy strategy = new org.apache.activemq.plugin.jaxb2_commons.ElementAwareEqualsStrategy(); 2861 return equals(null, null, object, strategy); 2862 } 2863 2864 } 2865 2866 2867 /** 2868 * <p>Java class for anonymous complex type. 2869 * 2870 * <p>The following schema fragment specifies the expected content contained within this class. 2871 * 2872 * <pre> 2873 * <complexType> 2874 * <complexContent> 2875 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 2876 * <choice minOccurs="0"> 2877 * <element ref="{http://activemq.apache.org/schema/core}database-locker"/> 2878 * <element ref="{http://activemq.apache.org/schema/core}lease-database-locker"/> 2879 * <element ref="{http://activemq.apache.org/schema/core}shared-file-locker"/> 2880 * <element ref="{http://activemq.apache.org/schema/core}transact-database-locker"/> 2881 * <any namespace='##other'/> 2882 * </choice> 2883 * </restriction> 2884 * </complexContent> 2885 * </complexType> 2886 * </pre> 2887 * 2888 * 2889 */ 2890 @XmlAccessorType(XmlAccessType.FIELD) 2891 @XmlType(name = "", propOrder = { 2892 "databaseLocker", 2893 "leaseDatabaseLocker", 2894 "sharedFileLocker", 2895 "transactDatabaseLocker", 2896 "any" 2897 }) 2898 public static class DatabaseLocker 2899 implements Equals, HashCode, ToString 2900 { 2901 2902 @XmlElement(name = "database-locker") 2903 protected DtoDatabaseLocker databaseLocker; 2904 @XmlElement(name = "lease-database-locker") 2905 protected DtoLeaseDatabaseLocker leaseDatabaseLocker; 2906 @XmlElement(name = "shared-file-locker") 2907 protected DtoSharedFileLocker sharedFileLocker; 2908 @XmlElement(name = "transact-database-locker") 2909 protected DtoTransactDatabaseLocker transactDatabaseLocker; 2910 @XmlAnyElement(lax = true) 2911 protected Object any; 2912 2913 /** 2914 * Gets the value of the databaseLocker property. 2915 * 2916 * @return 2917 * possible object is 2918 * {@link DtoDatabaseLocker } 2919 * 2920 */ 2921 public DtoDatabaseLocker getDatabaseLocker() { 2922 return databaseLocker; 2923 } 2924 2925 /** 2926 * Sets the value of the databaseLocker property. 2927 * 2928 * @param value 2929 * allowed object is 2930 * {@link DtoDatabaseLocker } 2931 * 2932 */ 2933 public void setDatabaseLocker(DtoDatabaseLocker value) { 2934 this.databaseLocker = value; 2935 } 2936 2937 /** 2938 * Gets the value of the leaseDatabaseLocker property. 2939 * 2940 * @return 2941 * possible object is 2942 * {@link DtoLeaseDatabaseLocker } 2943 * 2944 */ 2945 public DtoLeaseDatabaseLocker getLeaseDatabaseLocker() { 2946 return leaseDatabaseLocker; 2947 } 2948 2949 /** 2950 * Sets the value of the leaseDatabaseLocker property. 2951 * 2952 * @param value 2953 * allowed object is 2954 * {@link DtoLeaseDatabaseLocker } 2955 * 2956 */ 2957 public void setLeaseDatabaseLocker(DtoLeaseDatabaseLocker value) { 2958 this.leaseDatabaseLocker = value; 2959 } 2960 2961 /** 2962 * Gets the value of the sharedFileLocker property. 2963 * 2964 * @return 2965 * possible object is 2966 * {@link DtoSharedFileLocker } 2967 * 2968 */ 2969 public DtoSharedFileLocker getSharedFileLocker() { 2970 return sharedFileLocker; 2971 } 2972 2973 /** 2974 * Sets the value of the sharedFileLocker property. 2975 * 2976 * @param value 2977 * allowed object is 2978 * {@link DtoSharedFileLocker } 2979 * 2980 */ 2981 public void setSharedFileLocker(DtoSharedFileLocker value) { 2982 this.sharedFileLocker = value; 2983 } 2984 2985 /** 2986 * Gets the value of the transactDatabaseLocker property. 2987 * 2988 * @return 2989 * possible object is 2990 * {@link DtoTransactDatabaseLocker } 2991 * 2992 */ 2993 public DtoTransactDatabaseLocker getTransactDatabaseLocker() { 2994 return transactDatabaseLocker; 2995 } 2996 2997 /** 2998 * Sets the value of the transactDatabaseLocker property. 2999 * 3000 * @param value 3001 * allowed object is 3002 * {@link DtoTransactDatabaseLocker } 3003 * 3004 */ 3005 public void setTransactDatabaseLocker(DtoTransactDatabaseLocker value) { 3006 this.transactDatabaseLocker = value; 3007 } 3008 3009 /** 3010 * Gets the value of the any property. 3011 * 3012 * @return 3013 * possible object is 3014 * {@link Object } 3015 * 3016 */ 3017 public Object getAny() { 3018 return any; 3019 } 3020 3021 /** 3022 * Sets the value of the any property. 3023 * 3024 * @param value 3025 * allowed object is 3026 * {@link Object } 3027 * 3028 */ 3029 public void setAny(Object value) { 3030 this.any = value; 3031 } 3032 3033 public String toString() { 3034 final ToStringStrategy strategy = JAXBToStringStrategy.INSTANCE; 3035 final StringBuilder buffer = new StringBuilder(); 3036 append(null, buffer, strategy); 3037 return buffer.toString(); 3038 } 3039 3040 public StringBuilder append(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 3041 strategy.appendStart(locator, this, buffer); 3042 appendFields(locator, buffer, strategy); 3043 strategy.appendEnd(locator, this, buffer); 3044 return buffer; 3045 } 3046 3047 public StringBuilder appendFields(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 3048 { 3049 DtoDatabaseLocker theDatabaseLocker; 3050 theDatabaseLocker = this.getDatabaseLocker(); 3051 strategy.appendField(locator, this, "databaseLocker", buffer, theDatabaseLocker); 3052 } 3053 { 3054 DtoLeaseDatabaseLocker theLeaseDatabaseLocker; 3055 theLeaseDatabaseLocker = this.getLeaseDatabaseLocker(); 3056 strategy.appendField(locator, this, "leaseDatabaseLocker", buffer, theLeaseDatabaseLocker); 3057 } 3058 { 3059 DtoSharedFileLocker theSharedFileLocker; 3060 theSharedFileLocker = this.getSharedFileLocker(); 3061 strategy.appendField(locator, this, "sharedFileLocker", buffer, theSharedFileLocker); 3062 } 3063 { 3064 DtoTransactDatabaseLocker theTransactDatabaseLocker; 3065 theTransactDatabaseLocker = this.getTransactDatabaseLocker(); 3066 strategy.appendField(locator, this, "transactDatabaseLocker", buffer, theTransactDatabaseLocker); 3067 } 3068 { 3069 Object theAny; 3070 theAny = this.getAny(); 3071 strategy.appendField(locator, this, "any", buffer, theAny); 3072 } 3073 return buffer; 3074 } 3075 3076 public int hashCode(ObjectLocator locator, HashCodeStrategy strategy) { 3077 int currentHashCode = 1; 3078 { 3079 DtoDatabaseLocker theDatabaseLocker; 3080 theDatabaseLocker = this.getDatabaseLocker(); 3081 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "databaseLocker", theDatabaseLocker), currentHashCode, theDatabaseLocker); 3082 } 3083 { 3084 DtoLeaseDatabaseLocker theLeaseDatabaseLocker; 3085 theLeaseDatabaseLocker = this.getLeaseDatabaseLocker(); 3086 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "leaseDatabaseLocker", theLeaseDatabaseLocker), currentHashCode, theLeaseDatabaseLocker); 3087 } 3088 { 3089 DtoSharedFileLocker theSharedFileLocker; 3090 theSharedFileLocker = this.getSharedFileLocker(); 3091 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "sharedFileLocker", theSharedFileLocker), currentHashCode, theSharedFileLocker); 3092 } 3093 { 3094 DtoTransactDatabaseLocker theTransactDatabaseLocker; 3095 theTransactDatabaseLocker = this.getTransactDatabaseLocker(); 3096 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "transactDatabaseLocker", theTransactDatabaseLocker), currentHashCode, theTransactDatabaseLocker); 3097 } 3098 { 3099 Object theAny; 3100 theAny = this.getAny(); 3101 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "any", theAny), currentHashCode, theAny); 3102 } 3103 return currentHashCode; 3104 } 3105 3106 public int hashCode() { 3107 final HashCodeStrategy strategy = JAXBHashCodeStrategy.INSTANCE; 3108 return this.hashCode(null, strategy); 3109 } 3110 3111 public boolean equals(ObjectLocator thisLocator, ObjectLocator thatLocator, Object object, EqualsStrategy strategy) { 3112 if (!(object instanceof DtoJdbcPersistenceAdapter.DatabaseLocker)) { 3113 return false; 3114 } 3115 if (this == object) { 3116 return true; 3117 } 3118 final DtoJdbcPersistenceAdapter.DatabaseLocker that = ((DtoJdbcPersistenceAdapter.DatabaseLocker) object); 3119 { 3120 DtoDatabaseLocker lhsDatabaseLocker; 3121 lhsDatabaseLocker = this.getDatabaseLocker(); 3122 DtoDatabaseLocker rhsDatabaseLocker; 3123 rhsDatabaseLocker = that.getDatabaseLocker(); 3124 if (!strategy.equals(LocatorUtils.property(thisLocator, "databaseLocker", lhsDatabaseLocker), LocatorUtils.property(thatLocator, "databaseLocker", rhsDatabaseLocker), lhsDatabaseLocker, rhsDatabaseLocker)) { 3125 return false; 3126 } 3127 } 3128 { 3129 DtoLeaseDatabaseLocker lhsLeaseDatabaseLocker; 3130 lhsLeaseDatabaseLocker = this.getLeaseDatabaseLocker(); 3131 DtoLeaseDatabaseLocker rhsLeaseDatabaseLocker; 3132 rhsLeaseDatabaseLocker = that.getLeaseDatabaseLocker(); 3133 if (!strategy.equals(LocatorUtils.property(thisLocator, "leaseDatabaseLocker", lhsLeaseDatabaseLocker), LocatorUtils.property(thatLocator, "leaseDatabaseLocker", rhsLeaseDatabaseLocker), lhsLeaseDatabaseLocker, rhsLeaseDatabaseLocker)) { 3134 return false; 3135 } 3136 } 3137 { 3138 DtoSharedFileLocker lhsSharedFileLocker; 3139 lhsSharedFileLocker = this.getSharedFileLocker(); 3140 DtoSharedFileLocker rhsSharedFileLocker; 3141 rhsSharedFileLocker = that.getSharedFileLocker(); 3142 if (!strategy.equals(LocatorUtils.property(thisLocator, "sharedFileLocker", lhsSharedFileLocker), LocatorUtils.property(thatLocator, "sharedFileLocker", rhsSharedFileLocker), lhsSharedFileLocker, rhsSharedFileLocker)) { 3143 return false; 3144 } 3145 } 3146 { 3147 DtoTransactDatabaseLocker lhsTransactDatabaseLocker; 3148 lhsTransactDatabaseLocker = this.getTransactDatabaseLocker(); 3149 DtoTransactDatabaseLocker rhsTransactDatabaseLocker; 3150 rhsTransactDatabaseLocker = that.getTransactDatabaseLocker(); 3151 if (!strategy.equals(LocatorUtils.property(thisLocator, "transactDatabaseLocker", lhsTransactDatabaseLocker), LocatorUtils.property(thatLocator, "transactDatabaseLocker", rhsTransactDatabaseLocker), lhsTransactDatabaseLocker, rhsTransactDatabaseLocker)) { 3152 return false; 3153 } 3154 } 3155 { 3156 Object lhsAny; 3157 lhsAny = this.getAny(); 3158 Object rhsAny; 3159 rhsAny = that.getAny(); 3160 if (!strategy.equals(LocatorUtils.property(thisLocator, "any", lhsAny), LocatorUtils.property(thatLocator, "any", rhsAny), lhsAny, rhsAny)) { 3161 return false; 3162 } 3163 } 3164 return true; 3165 } 3166 3167 public boolean equals(Object object) { 3168 final EqualsStrategy strategy = new org.apache.activemq.plugin.jaxb2_commons.ElementAwareEqualsStrategy(); 3169 return equals(null, null, object, strategy); 3170 } 3171 3172 } 3173 3174 3175 /** 3176 * <p>Java class for anonymous complex type. 3177 * 3178 * <p>The following schema fragment specifies the expected content contained within this class. 3179 * 3180 * <pre> 3181 * <complexType> 3182 * <complexContent> 3183 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 3184 * <sequence minOccurs="0"> 3185 * <any maxOccurs="unbounded" minOccurs="0"/> 3186 * </sequence> 3187 * </restriction> 3188 * </complexContent> 3189 * </complexType> 3190 * </pre> 3191 * 3192 * 3193 */ 3194 @XmlAccessorType(XmlAccessType.FIELD) 3195 @XmlType(name = "", propOrder = { 3196 "any" 3197 }) 3198 public static class DataSource 3199 implements Equals, HashCode, ToString 3200 { 3201 3202 @XmlAnyElement(lax = true) 3203 protected List<Object> any; 3204 3205 /** 3206 * Gets the value of the any property. 3207 * 3208 * <p> 3209 * This accessor method returns a reference to the live list, 3210 * not a snapshot. Therefore any modification you make to the 3211 * returned list will be present inside the JAXB object. 3212 * This is why there is not a <CODE>set</CODE> method for the any property. 3213 * 3214 * <p> 3215 * For example, to add a new item, do as follows: 3216 * <pre> 3217 * getAny().add(newItem); 3218 * </pre> 3219 * 3220 * 3221 * <p> 3222 * Objects of the following type(s) are allowed in the list 3223 * {@link Object } 3224 * 3225 * 3226 */ 3227 public List<Object> getAny() { 3228 if (any == null) { 3229 any = new ArrayList<Object>(); 3230 } 3231 return this.any; 3232 } 3233 3234 public String toString() { 3235 final ToStringStrategy strategy = JAXBToStringStrategy.INSTANCE; 3236 final StringBuilder buffer = new StringBuilder(); 3237 append(null, buffer, strategy); 3238 return buffer.toString(); 3239 } 3240 3241 public StringBuilder append(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 3242 strategy.appendStart(locator, this, buffer); 3243 appendFields(locator, buffer, strategy); 3244 strategy.appendEnd(locator, this, buffer); 3245 return buffer; 3246 } 3247 3248 public StringBuilder appendFields(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 3249 { 3250 List<Object> theAny; 3251 theAny = (((this.any!= null)&&(!this.any.isEmpty()))?this.getAny():null); 3252 strategy.appendField(locator, this, "any", buffer, theAny); 3253 } 3254 return buffer; 3255 } 3256 3257 public int hashCode(ObjectLocator locator, HashCodeStrategy strategy) { 3258 int currentHashCode = 1; 3259 { 3260 List<Object> theAny; 3261 theAny = (((this.any!= null)&&(!this.any.isEmpty()))?this.getAny():null); 3262 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "any", theAny), currentHashCode, theAny); 3263 } 3264 return currentHashCode; 3265 } 3266 3267 public int hashCode() { 3268 final HashCodeStrategy strategy = JAXBHashCodeStrategy.INSTANCE; 3269 return this.hashCode(null, strategy); 3270 } 3271 3272 public boolean equals(ObjectLocator thisLocator, ObjectLocator thatLocator, Object object, EqualsStrategy strategy) { 3273 if (!(object instanceof DtoJdbcPersistenceAdapter.DataSource)) { 3274 return false; 3275 } 3276 if (this == object) { 3277 return true; 3278 } 3279 final DtoJdbcPersistenceAdapter.DataSource that = ((DtoJdbcPersistenceAdapter.DataSource) object); 3280 { 3281 List<Object> lhsAny; 3282 lhsAny = (((this.any!= null)&&(!this.any.isEmpty()))?this.getAny():null); 3283 List<Object> rhsAny; 3284 rhsAny = (((that.any!= null)&&(!that.any.isEmpty()))?that.getAny():null); 3285 if (!strategy.equals(LocatorUtils.property(thisLocator, "any", lhsAny), LocatorUtils.property(thatLocator, "any", rhsAny), lhsAny, rhsAny)) { 3286 return false; 3287 } 3288 } 3289 return true; 3290 } 3291 3292 public boolean equals(Object object) { 3293 final EqualsStrategy strategy = new org.apache.activemq.plugin.jaxb2_commons.ElementAwareEqualsStrategy(); 3294 return equals(null, null, object, strategy); 3295 } 3296 3297 } 3298 3299 3300 /** 3301 * <p>Java class for anonymous complex type. 3302 * 3303 * <p>The following schema fragment specifies the expected content contained within this class. 3304 * 3305 * <pre> 3306 * <complexType> 3307 * <complexContent> 3308 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 3309 * <sequence minOccurs="0"> 3310 * <any maxOccurs="unbounded" minOccurs="0"/> 3311 * </sequence> 3312 * </restriction> 3313 * </complexContent> 3314 * </complexType> 3315 * </pre> 3316 * 3317 * 3318 */ 3319 @XmlAccessorType(XmlAccessType.FIELD) 3320 @XmlType(name = "", propOrder = { 3321 "any" 3322 }) 3323 public static class Ds 3324 implements Equals, HashCode, ToString 3325 { 3326 3327 @XmlAnyElement(lax = true) 3328 protected List<Object> any; 3329 3330 /** 3331 * Gets the value of the any property. 3332 * 3333 * <p> 3334 * This accessor method returns a reference to the live list, 3335 * not a snapshot. Therefore any modification you make to the 3336 * returned list will be present inside the JAXB object. 3337 * This is why there is not a <CODE>set</CODE> method for the any property. 3338 * 3339 * <p> 3340 * For example, to add a new item, do as follows: 3341 * <pre> 3342 * getAny().add(newItem); 3343 * </pre> 3344 * 3345 * 3346 * <p> 3347 * Objects of the following type(s) are allowed in the list 3348 * {@link Object } 3349 * 3350 * 3351 */ 3352 public List<Object> getAny() { 3353 if (any == null) { 3354 any = new ArrayList<Object>(); 3355 } 3356 return this.any; 3357 } 3358 3359 public String toString() { 3360 final ToStringStrategy strategy = JAXBToStringStrategy.INSTANCE; 3361 final StringBuilder buffer = new StringBuilder(); 3362 append(null, buffer, strategy); 3363 return buffer.toString(); 3364 } 3365 3366 public StringBuilder append(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 3367 strategy.appendStart(locator, this, buffer); 3368 appendFields(locator, buffer, strategy); 3369 strategy.appendEnd(locator, this, buffer); 3370 return buffer; 3371 } 3372 3373 public StringBuilder appendFields(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 3374 { 3375 List<Object> theAny; 3376 theAny = (((this.any!= null)&&(!this.any.isEmpty()))?this.getAny():null); 3377 strategy.appendField(locator, this, "any", buffer, theAny); 3378 } 3379 return buffer; 3380 } 3381 3382 public int hashCode(ObjectLocator locator, HashCodeStrategy strategy) { 3383 int currentHashCode = 1; 3384 { 3385 List<Object> theAny; 3386 theAny = (((this.any!= null)&&(!this.any.isEmpty()))?this.getAny():null); 3387 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "any", theAny), currentHashCode, theAny); 3388 } 3389 return currentHashCode; 3390 } 3391 3392 public int hashCode() { 3393 final HashCodeStrategy strategy = JAXBHashCodeStrategy.INSTANCE; 3394 return this.hashCode(null, strategy); 3395 } 3396 3397 public boolean equals(ObjectLocator thisLocator, ObjectLocator thatLocator, Object object, EqualsStrategy strategy) { 3398 if (!(object instanceof DtoJdbcPersistenceAdapter.Ds)) { 3399 return false; 3400 } 3401 if (this == object) { 3402 return true; 3403 } 3404 final DtoJdbcPersistenceAdapter.Ds that = ((DtoJdbcPersistenceAdapter.Ds) object); 3405 { 3406 List<Object> lhsAny; 3407 lhsAny = (((this.any!= null)&&(!this.any.isEmpty()))?this.getAny():null); 3408 List<Object> rhsAny; 3409 rhsAny = (((that.any!= null)&&(!that.any.isEmpty()))?that.getAny():null); 3410 if (!strategy.equals(LocatorUtils.property(thisLocator, "any", lhsAny), LocatorUtils.property(thatLocator, "any", rhsAny), lhsAny, rhsAny)) { 3411 return false; 3412 } 3413 } 3414 return true; 3415 } 3416 3417 public boolean equals(Object object) { 3418 final EqualsStrategy strategy = new org.apache.activemq.plugin.jaxb2_commons.ElementAwareEqualsStrategy(); 3419 return equals(null, null, object, strategy); 3420 } 3421 3422 } 3423 3424 3425 /** 3426 * <p>Java class for anonymous complex type. 3427 * 3428 * <p>The following schema fragment specifies the expected content contained within this class. 3429 * 3430 * <pre> 3431 * <complexType> 3432 * <complexContent> 3433 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 3434 * <sequence minOccurs="0"> 3435 * <any maxOccurs="unbounded" minOccurs="0"/> 3436 * </sequence> 3437 * </restriction> 3438 * </complexContent> 3439 * </complexType> 3440 * </pre> 3441 * 3442 * 3443 */ 3444 @XmlAccessorType(XmlAccessType.FIELD) 3445 @XmlType(name = "", propOrder = { 3446 "any" 3447 }) 3448 public static class LockDataSource 3449 implements Equals, HashCode, ToString 3450 { 3451 3452 @XmlAnyElement(lax = true) 3453 protected List<Object> any; 3454 3455 /** 3456 * Gets the value of the any property. 3457 * 3458 * <p> 3459 * This accessor method returns a reference to the live list, 3460 * not a snapshot. Therefore any modification you make to the 3461 * returned list will be present inside the JAXB object. 3462 * This is why there is not a <CODE>set</CODE> method for the any property. 3463 * 3464 * <p> 3465 * For example, to add a new item, do as follows: 3466 * <pre> 3467 * getAny().add(newItem); 3468 * </pre> 3469 * 3470 * 3471 * <p> 3472 * Objects of the following type(s) are allowed in the list 3473 * {@link Object } 3474 * 3475 * 3476 */ 3477 public List<Object> getAny() { 3478 if (any == null) { 3479 any = new ArrayList<Object>(); 3480 } 3481 return this.any; 3482 } 3483 3484 public String toString() { 3485 final ToStringStrategy strategy = JAXBToStringStrategy.INSTANCE; 3486 final StringBuilder buffer = new StringBuilder(); 3487 append(null, buffer, strategy); 3488 return buffer.toString(); 3489 } 3490 3491 public StringBuilder append(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 3492 strategy.appendStart(locator, this, buffer); 3493 appendFields(locator, buffer, strategy); 3494 strategy.appendEnd(locator, this, buffer); 3495 return buffer; 3496 } 3497 3498 public StringBuilder appendFields(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 3499 { 3500 List<Object> theAny; 3501 theAny = (((this.any!= null)&&(!this.any.isEmpty()))?this.getAny():null); 3502 strategy.appendField(locator, this, "any", buffer, theAny); 3503 } 3504 return buffer; 3505 } 3506 3507 public int hashCode(ObjectLocator locator, HashCodeStrategy strategy) { 3508 int currentHashCode = 1; 3509 { 3510 List<Object> theAny; 3511 theAny = (((this.any!= null)&&(!this.any.isEmpty()))?this.getAny():null); 3512 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "any", theAny), currentHashCode, theAny); 3513 } 3514 return currentHashCode; 3515 } 3516 3517 public int hashCode() { 3518 final HashCodeStrategy strategy = JAXBHashCodeStrategy.INSTANCE; 3519 return this.hashCode(null, strategy); 3520 } 3521 3522 public boolean equals(ObjectLocator thisLocator, ObjectLocator thatLocator, Object object, EqualsStrategy strategy) { 3523 if (!(object instanceof DtoJdbcPersistenceAdapter.LockDataSource)) { 3524 return false; 3525 } 3526 if (this == object) { 3527 return true; 3528 } 3529 final DtoJdbcPersistenceAdapter.LockDataSource that = ((DtoJdbcPersistenceAdapter.LockDataSource) object); 3530 { 3531 List<Object> lhsAny; 3532 lhsAny = (((this.any!= null)&&(!this.any.isEmpty()))?this.getAny():null); 3533 List<Object> rhsAny; 3534 rhsAny = (((that.any!= null)&&(!that.any.isEmpty()))?that.getAny():null); 3535 if (!strategy.equals(LocatorUtils.property(thisLocator, "any", lhsAny), LocatorUtils.property(thatLocator, "any", rhsAny), lhsAny, rhsAny)) { 3536 return false; 3537 } 3538 } 3539 return true; 3540 } 3541 3542 public boolean equals(Object object) { 3543 final EqualsStrategy strategy = new org.apache.activemq.plugin.jaxb2_commons.ElementAwareEqualsStrategy(); 3544 return equals(null, null, object, strategy); 3545 } 3546 3547 } 3548 3549 3550 /** 3551 * <p>Java class for anonymous complex type. 3552 * 3553 * <p>The following schema fragment specifies the expected content contained within this class. 3554 * 3555 * <pre> 3556 * <complexType> 3557 * <complexContent> 3558 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 3559 * <choice minOccurs="0"> 3560 * <element ref="{http://activemq.apache.org/schema/core}database-locker"/> 3561 * <element ref="{http://activemq.apache.org/schema/core}lease-database-locker"/> 3562 * <element ref="{http://activemq.apache.org/schema/core}shared-file-locker"/> 3563 * <element ref="{http://activemq.apache.org/schema/core}transact-database-locker"/> 3564 * <any namespace='##other'/> 3565 * </choice> 3566 * </restriction> 3567 * </complexContent> 3568 * </complexType> 3569 * </pre> 3570 * 3571 * 3572 */ 3573 @XmlAccessorType(XmlAccessType.FIELD) 3574 @XmlType(name = "", propOrder = { 3575 "databaseLocker", 3576 "leaseDatabaseLocker", 3577 "sharedFileLocker", 3578 "transactDatabaseLocker", 3579 "any" 3580 }) 3581 public static class Locker 3582 implements Equals, HashCode, ToString 3583 { 3584 3585 @XmlElement(name = "database-locker") 3586 protected DtoDatabaseLocker databaseLocker; 3587 @XmlElement(name = "lease-database-locker") 3588 protected DtoLeaseDatabaseLocker leaseDatabaseLocker; 3589 @XmlElement(name = "shared-file-locker") 3590 protected DtoSharedFileLocker sharedFileLocker; 3591 @XmlElement(name = "transact-database-locker") 3592 protected DtoTransactDatabaseLocker transactDatabaseLocker; 3593 @XmlAnyElement(lax = true) 3594 protected Object any; 3595 3596 /** 3597 * Gets the value of the databaseLocker property. 3598 * 3599 * @return 3600 * possible object is 3601 * {@link DtoDatabaseLocker } 3602 * 3603 */ 3604 public DtoDatabaseLocker getDatabaseLocker() { 3605 return databaseLocker; 3606 } 3607 3608 /** 3609 * Sets the value of the databaseLocker property. 3610 * 3611 * @param value 3612 * allowed object is 3613 * {@link DtoDatabaseLocker } 3614 * 3615 */ 3616 public void setDatabaseLocker(DtoDatabaseLocker value) { 3617 this.databaseLocker = value; 3618 } 3619 3620 /** 3621 * Gets the value of the leaseDatabaseLocker property. 3622 * 3623 * @return 3624 * possible object is 3625 * {@link DtoLeaseDatabaseLocker } 3626 * 3627 */ 3628 public DtoLeaseDatabaseLocker getLeaseDatabaseLocker() { 3629 return leaseDatabaseLocker; 3630 } 3631 3632 /** 3633 * Sets the value of the leaseDatabaseLocker property. 3634 * 3635 * @param value 3636 * allowed object is 3637 * {@link DtoLeaseDatabaseLocker } 3638 * 3639 */ 3640 public void setLeaseDatabaseLocker(DtoLeaseDatabaseLocker value) { 3641 this.leaseDatabaseLocker = value; 3642 } 3643 3644 /** 3645 * Gets the value of the sharedFileLocker property. 3646 * 3647 * @return 3648 * possible object is 3649 * {@link DtoSharedFileLocker } 3650 * 3651 */ 3652 public DtoSharedFileLocker getSharedFileLocker() { 3653 return sharedFileLocker; 3654 } 3655 3656 /** 3657 * Sets the value of the sharedFileLocker property. 3658 * 3659 * @param value 3660 * allowed object is 3661 * {@link DtoSharedFileLocker } 3662 * 3663 */ 3664 public void setSharedFileLocker(DtoSharedFileLocker value) { 3665 this.sharedFileLocker = value; 3666 } 3667 3668 /** 3669 * Gets the value of the transactDatabaseLocker property. 3670 * 3671 * @return 3672 * possible object is 3673 * {@link DtoTransactDatabaseLocker } 3674 * 3675 */ 3676 public DtoTransactDatabaseLocker getTransactDatabaseLocker() { 3677 return transactDatabaseLocker; 3678 } 3679 3680 /** 3681 * Sets the value of the transactDatabaseLocker property. 3682 * 3683 * @param value 3684 * allowed object is 3685 * {@link DtoTransactDatabaseLocker } 3686 * 3687 */ 3688 public void setTransactDatabaseLocker(DtoTransactDatabaseLocker value) { 3689 this.transactDatabaseLocker = value; 3690 } 3691 3692 /** 3693 * Gets the value of the any property. 3694 * 3695 * @return 3696 * possible object is 3697 * {@link Object } 3698 * 3699 */ 3700 public Object getAny() { 3701 return any; 3702 } 3703 3704 /** 3705 * Sets the value of the any property. 3706 * 3707 * @param value 3708 * allowed object is 3709 * {@link Object } 3710 * 3711 */ 3712 public void setAny(Object value) { 3713 this.any = value; 3714 } 3715 3716 public String toString() { 3717 final ToStringStrategy strategy = JAXBToStringStrategy.INSTANCE; 3718 final StringBuilder buffer = new StringBuilder(); 3719 append(null, buffer, strategy); 3720 return buffer.toString(); 3721 } 3722 3723 public StringBuilder append(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 3724 strategy.appendStart(locator, this, buffer); 3725 appendFields(locator, buffer, strategy); 3726 strategy.appendEnd(locator, this, buffer); 3727 return buffer; 3728 } 3729 3730 public StringBuilder appendFields(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 3731 { 3732 DtoDatabaseLocker theDatabaseLocker; 3733 theDatabaseLocker = this.getDatabaseLocker(); 3734 strategy.appendField(locator, this, "databaseLocker", buffer, theDatabaseLocker); 3735 } 3736 { 3737 DtoLeaseDatabaseLocker theLeaseDatabaseLocker; 3738 theLeaseDatabaseLocker = this.getLeaseDatabaseLocker(); 3739 strategy.appendField(locator, this, "leaseDatabaseLocker", buffer, theLeaseDatabaseLocker); 3740 } 3741 { 3742 DtoSharedFileLocker theSharedFileLocker; 3743 theSharedFileLocker = this.getSharedFileLocker(); 3744 strategy.appendField(locator, this, "sharedFileLocker", buffer, theSharedFileLocker); 3745 } 3746 { 3747 DtoTransactDatabaseLocker theTransactDatabaseLocker; 3748 theTransactDatabaseLocker = this.getTransactDatabaseLocker(); 3749 strategy.appendField(locator, this, "transactDatabaseLocker", buffer, theTransactDatabaseLocker); 3750 } 3751 { 3752 Object theAny; 3753 theAny = this.getAny(); 3754 strategy.appendField(locator, this, "any", buffer, theAny); 3755 } 3756 return buffer; 3757 } 3758 3759 public int hashCode(ObjectLocator locator, HashCodeStrategy strategy) { 3760 int currentHashCode = 1; 3761 { 3762 DtoDatabaseLocker theDatabaseLocker; 3763 theDatabaseLocker = this.getDatabaseLocker(); 3764 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "databaseLocker", theDatabaseLocker), currentHashCode, theDatabaseLocker); 3765 } 3766 { 3767 DtoLeaseDatabaseLocker theLeaseDatabaseLocker; 3768 theLeaseDatabaseLocker = this.getLeaseDatabaseLocker(); 3769 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "leaseDatabaseLocker", theLeaseDatabaseLocker), currentHashCode, theLeaseDatabaseLocker); 3770 } 3771 { 3772 DtoSharedFileLocker theSharedFileLocker; 3773 theSharedFileLocker = this.getSharedFileLocker(); 3774 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "sharedFileLocker", theSharedFileLocker), currentHashCode, theSharedFileLocker); 3775 } 3776 { 3777 DtoTransactDatabaseLocker theTransactDatabaseLocker; 3778 theTransactDatabaseLocker = this.getTransactDatabaseLocker(); 3779 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "transactDatabaseLocker", theTransactDatabaseLocker), currentHashCode, theTransactDatabaseLocker); 3780 } 3781 { 3782 Object theAny; 3783 theAny = this.getAny(); 3784 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "any", theAny), currentHashCode, theAny); 3785 } 3786 return currentHashCode; 3787 } 3788 3789 public int hashCode() { 3790 final HashCodeStrategy strategy = JAXBHashCodeStrategy.INSTANCE; 3791 return this.hashCode(null, strategy); 3792 } 3793 3794 public boolean equals(ObjectLocator thisLocator, ObjectLocator thatLocator, Object object, EqualsStrategy strategy) { 3795 if (!(object instanceof DtoJdbcPersistenceAdapter.Locker)) { 3796 return false; 3797 } 3798 if (this == object) { 3799 return true; 3800 } 3801 final DtoJdbcPersistenceAdapter.Locker that = ((DtoJdbcPersistenceAdapter.Locker) object); 3802 { 3803 DtoDatabaseLocker lhsDatabaseLocker; 3804 lhsDatabaseLocker = this.getDatabaseLocker(); 3805 DtoDatabaseLocker rhsDatabaseLocker; 3806 rhsDatabaseLocker = that.getDatabaseLocker(); 3807 if (!strategy.equals(LocatorUtils.property(thisLocator, "databaseLocker", lhsDatabaseLocker), LocatorUtils.property(thatLocator, "databaseLocker", rhsDatabaseLocker), lhsDatabaseLocker, rhsDatabaseLocker)) { 3808 return false; 3809 } 3810 } 3811 { 3812 DtoLeaseDatabaseLocker lhsLeaseDatabaseLocker; 3813 lhsLeaseDatabaseLocker = this.getLeaseDatabaseLocker(); 3814 DtoLeaseDatabaseLocker rhsLeaseDatabaseLocker; 3815 rhsLeaseDatabaseLocker = that.getLeaseDatabaseLocker(); 3816 if (!strategy.equals(LocatorUtils.property(thisLocator, "leaseDatabaseLocker", lhsLeaseDatabaseLocker), LocatorUtils.property(thatLocator, "leaseDatabaseLocker", rhsLeaseDatabaseLocker), lhsLeaseDatabaseLocker, rhsLeaseDatabaseLocker)) { 3817 return false; 3818 } 3819 } 3820 { 3821 DtoSharedFileLocker lhsSharedFileLocker; 3822 lhsSharedFileLocker = this.getSharedFileLocker(); 3823 DtoSharedFileLocker rhsSharedFileLocker; 3824 rhsSharedFileLocker = that.getSharedFileLocker(); 3825 if (!strategy.equals(LocatorUtils.property(thisLocator, "sharedFileLocker", lhsSharedFileLocker), LocatorUtils.property(thatLocator, "sharedFileLocker", rhsSharedFileLocker), lhsSharedFileLocker, rhsSharedFileLocker)) { 3826 return false; 3827 } 3828 } 3829 { 3830 DtoTransactDatabaseLocker lhsTransactDatabaseLocker; 3831 lhsTransactDatabaseLocker = this.getTransactDatabaseLocker(); 3832 DtoTransactDatabaseLocker rhsTransactDatabaseLocker; 3833 rhsTransactDatabaseLocker = that.getTransactDatabaseLocker(); 3834 if (!strategy.equals(LocatorUtils.property(thisLocator, "transactDatabaseLocker", lhsTransactDatabaseLocker), LocatorUtils.property(thatLocator, "transactDatabaseLocker", rhsTransactDatabaseLocker), lhsTransactDatabaseLocker, rhsTransactDatabaseLocker)) { 3835 return false; 3836 } 3837 } 3838 { 3839 Object lhsAny; 3840 lhsAny = this.getAny(); 3841 Object rhsAny; 3842 rhsAny = that.getAny(); 3843 if (!strategy.equals(LocatorUtils.property(thisLocator, "any", lhsAny), LocatorUtils.property(thatLocator, "any", rhsAny), lhsAny, rhsAny)) { 3844 return false; 3845 } 3846 } 3847 return true; 3848 } 3849 3850 public boolean equals(Object object) { 3851 final EqualsStrategy strategy = new org.apache.activemq.plugin.jaxb2_commons.ElementAwareEqualsStrategy(); 3852 return equals(null, null, object, strategy); 3853 } 3854 3855 } 3856 3857 3858 /** 3859 * <p>Java class for anonymous complex type. 3860 * 3861 * <p>The following schema fragment specifies the expected content contained within this class. 3862 * 3863 * <pre> 3864 * <complexType> 3865 * <complexContent> 3866 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 3867 * <sequence minOccurs="0"> 3868 * <any maxOccurs="unbounded" minOccurs="0"/> 3869 * </sequence> 3870 * </restriction> 3871 * </complexContent> 3872 * </complexType> 3873 * </pre> 3874 * 3875 * 3876 */ 3877 @XmlAccessorType(XmlAccessType.FIELD) 3878 @XmlType(name = "", propOrder = { 3879 "any" 3880 }) 3881 public static class ScheduledThreadPoolExecutor 3882 implements Equals, HashCode, ToString 3883 { 3884 3885 @XmlAnyElement(lax = true) 3886 protected List<Object> any; 3887 3888 /** 3889 * Gets the value of the any property. 3890 * 3891 * <p> 3892 * This accessor method returns a reference to the live list, 3893 * not a snapshot. Therefore any modification you make to the 3894 * returned list will be present inside the JAXB object. 3895 * This is why there is not a <CODE>set</CODE> method for the any property. 3896 * 3897 * <p> 3898 * For example, to add a new item, do as follows: 3899 * <pre> 3900 * getAny().add(newItem); 3901 * </pre> 3902 * 3903 * 3904 * <p> 3905 * Objects of the following type(s) are allowed in the list 3906 * {@link Object } 3907 * 3908 * 3909 */ 3910 public List<Object> getAny() { 3911 if (any == null) { 3912 any = new ArrayList<Object>(); 3913 } 3914 return this.any; 3915 } 3916 3917 public String toString() { 3918 final ToStringStrategy strategy = JAXBToStringStrategy.INSTANCE; 3919 final StringBuilder buffer = new StringBuilder(); 3920 append(null, buffer, strategy); 3921 return buffer.toString(); 3922 } 3923 3924 public StringBuilder append(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 3925 strategy.appendStart(locator, this, buffer); 3926 appendFields(locator, buffer, strategy); 3927 strategy.appendEnd(locator, this, buffer); 3928 return buffer; 3929 } 3930 3931 public StringBuilder appendFields(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 3932 { 3933 List<Object> theAny; 3934 theAny = (((this.any!= null)&&(!this.any.isEmpty()))?this.getAny():null); 3935 strategy.appendField(locator, this, "any", buffer, theAny); 3936 } 3937 return buffer; 3938 } 3939 3940 public int hashCode(ObjectLocator locator, HashCodeStrategy strategy) { 3941 int currentHashCode = 1; 3942 { 3943 List<Object> theAny; 3944 theAny = (((this.any!= null)&&(!this.any.isEmpty()))?this.getAny():null); 3945 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "any", theAny), currentHashCode, theAny); 3946 } 3947 return currentHashCode; 3948 } 3949 3950 public int hashCode() { 3951 final HashCodeStrategy strategy = JAXBHashCodeStrategy.INSTANCE; 3952 return this.hashCode(null, strategy); 3953 } 3954 3955 public boolean equals(ObjectLocator thisLocator, ObjectLocator thatLocator, Object object, EqualsStrategy strategy) { 3956 if (!(object instanceof DtoJdbcPersistenceAdapter.ScheduledThreadPoolExecutor)) { 3957 return false; 3958 } 3959 if (this == object) { 3960 return true; 3961 } 3962 final DtoJdbcPersistenceAdapter.ScheduledThreadPoolExecutor that = ((DtoJdbcPersistenceAdapter.ScheduledThreadPoolExecutor) object); 3963 { 3964 List<Object> lhsAny; 3965 lhsAny = (((this.any!= null)&&(!this.any.isEmpty()))?this.getAny():null); 3966 List<Object> rhsAny; 3967 rhsAny = (((that.any!= null)&&(!that.any.isEmpty()))?that.getAny():null); 3968 if (!strategy.equals(LocatorUtils.property(thisLocator, "any", lhsAny), LocatorUtils.property(thatLocator, "any", rhsAny), lhsAny, rhsAny)) { 3969 return false; 3970 } 3971 } 3972 return true; 3973 } 3974 3975 public boolean equals(Object object) { 3976 final EqualsStrategy strategy = new org.apache.activemq.plugin.jaxb2_commons.ElementAwareEqualsStrategy(); 3977 return equals(null, null, object, strategy); 3978 } 3979 3980 } 3981 3982 3983 /** 3984 * <p>Java class for anonymous complex type. 3985 * 3986 * <p>The following schema fragment specifies the expected content contained within this class. 3987 * 3988 * <pre> 3989 * <complexType> 3990 * <complexContent> 3991 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 3992 * <choice minOccurs="0"> 3993 * <element ref="{http://activemq.apache.org/schema/core}statements"/> 3994 * <any namespace='##other'/> 3995 * </choice> 3996 * </restriction> 3997 * </complexContent> 3998 * </complexType> 3999 * </pre> 4000 * 4001 * 4002 */ 4003 @XmlAccessorType(XmlAccessType.FIELD) 4004 @XmlType(name = "", propOrder = { 4005 "statements", 4006 "any" 4007 }) 4008 public static class Statements 4009 implements Equals, HashCode, ToString 4010 { 4011 4012 protected DtoStatements statements; 4013 @XmlAnyElement(lax = true) 4014 protected Object any; 4015 4016 /** 4017 * Gets the value of the statements property. 4018 * 4019 * @return 4020 * possible object is 4021 * {@link DtoStatements } 4022 * 4023 */ 4024 public DtoStatements getStatements() { 4025 return statements; 4026 } 4027 4028 /** 4029 * Sets the value of the statements property. 4030 * 4031 * @param value 4032 * allowed object is 4033 * {@link DtoStatements } 4034 * 4035 */ 4036 public void setStatements(DtoStatements value) { 4037 this.statements = value; 4038 } 4039 4040 /** 4041 * Gets the value of the any property. 4042 * 4043 * @return 4044 * possible object is 4045 * {@link Object } 4046 * 4047 */ 4048 public Object getAny() { 4049 return any; 4050 } 4051 4052 /** 4053 * Sets the value of the any property. 4054 * 4055 * @param value 4056 * allowed object is 4057 * {@link Object } 4058 * 4059 */ 4060 public void setAny(Object value) { 4061 this.any = value; 4062 } 4063 4064 public String toString() { 4065 final ToStringStrategy strategy = JAXBToStringStrategy.INSTANCE; 4066 final StringBuilder buffer = new StringBuilder(); 4067 append(null, buffer, strategy); 4068 return buffer.toString(); 4069 } 4070 4071 public StringBuilder append(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 4072 strategy.appendStart(locator, this, buffer); 4073 appendFields(locator, buffer, strategy); 4074 strategy.appendEnd(locator, this, buffer); 4075 return buffer; 4076 } 4077 4078 public StringBuilder appendFields(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 4079 { 4080 DtoStatements theStatements; 4081 theStatements = this.getStatements(); 4082 strategy.appendField(locator, this, "statements", buffer, theStatements); 4083 } 4084 { 4085 Object theAny; 4086 theAny = this.getAny(); 4087 strategy.appendField(locator, this, "any", buffer, theAny); 4088 } 4089 return buffer; 4090 } 4091 4092 public int hashCode(ObjectLocator locator, HashCodeStrategy strategy) { 4093 int currentHashCode = 1; 4094 { 4095 DtoStatements theStatements; 4096 theStatements = this.getStatements(); 4097 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "statements", theStatements), currentHashCode, theStatements); 4098 } 4099 { 4100 Object theAny; 4101 theAny = this.getAny(); 4102 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "any", theAny), currentHashCode, theAny); 4103 } 4104 return currentHashCode; 4105 } 4106 4107 public int hashCode() { 4108 final HashCodeStrategy strategy = JAXBHashCodeStrategy.INSTANCE; 4109 return this.hashCode(null, strategy); 4110 } 4111 4112 public boolean equals(ObjectLocator thisLocator, ObjectLocator thatLocator, Object object, EqualsStrategy strategy) { 4113 if (!(object instanceof DtoJdbcPersistenceAdapter.Statements)) { 4114 return false; 4115 } 4116 if (this == object) { 4117 return true; 4118 } 4119 final DtoJdbcPersistenceAdapter.Statements that = ((DtoJdbcPersistenceAdapter.Statements) object); 4120 { 4121 DtoStatements lhsStatements; 4122 lhsStatements = this.getStatements(); 4123 DtoStatements rhsStatements; 4124 rhsStatements = that.getStatements(); 4125 if (!strategy.equals(LocatorUtils.property(thisLocator, "statements", lhsStatements), LocatorUtils.property(thatLocator, "statements", rhsStatements), lhsStatements, rhsStatements)) { 4126 return false; 4127 } 4128 } 4129 { 4130 Object lhsAny; 4131 lhsAny = this.getAny(); 4132 Object rhsAny; 4133 rhsAny = that.getAny(); 4134 if (!strategy.equals(LocatorUtils.property(thisLocator, "any", lhsAny), LocatorUtils.property(thatLocator, "any", rhsAny), lhsAny, rhsAny)) { 4135 return false; 4136 } 4137 } 4138 return true; 4139 } 4140 4141 public boolean equals(Object object) { 4142 final EqualsStrategy strategy = new org.apache.activemq.plugin.jaxb2_commons.ElementAwareEqualsStrategy(); 4143 return equals(null, null, object, strategy); 4144 } 4145 4146 } 4147 4148 4149 /** 4150 * <p>Java class for anonymous complex type. 4151 * 4152 * <p>The following schema fragment specifies the expected content contained within this class. 4153 * 4154 * <pre> 4155 * <complexType> 4156 * <complexContent> 4157 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 4158 * <choice minOccurs="0"> 4159 * <element ref="{http://activemq.apache.org/schema/core}systemUsage"/> 4160 * <any namespace='##other'/> 4161 * </choice> 4162 * </restriction> 4163 * </complexContent> 4164 * </complexType> 4165 * </pre> 4166 * 4167 * 4168 */ 4169 @XmlAccessorType(XmlAccessType.FIELD) 4170 @XmlType(name = "", propOrder = { 4171 "systemUsage", 4172 "any" 4173 }) 4174 public static class UsageManager 4175 implements Equals, HashCode, ToString 4176 { 4177 4178 protected DtoSystemUsage systemUsage; 4179 @XmlAnyElement(lax = true) 4180 protected Object any; 4181 4182 /** 4183 * Gets the value of the systemUsage property. 4184 * 4185 * @return 4186 * possible object is 4187 * {@link DtoSystemUsage } 4188 * 4189 */ 4190 public DtoSystemUsage getSystemUsage() { 4191 return systemUsage; 4192 } 4193 4194 /** 4195 * Sets the value of the systemUsage property. 4196 * 4197 * @param value 4198 * allowed object is 4199 * {@link DtoSystemUsage } 4200 * 4201 */ 4202 public void setSystemUsage(DtoSystemUsage value) { 4203 this.systemUsage = value; 4204 } 4205 4206 /** 4207 * Gets the value of the any property. 4208 * 4209 * @return 4210 * possible object is 4211 * {@link Object } 4212 * 4213 */ 4214 public Object getAny() { 4215 return any; 4216 } 4217 4218 /** 4219 * Sets the value of the any property. 4220 * 4221 * @param value 4222 * allowed object is 4223 * {@link Object } 4224 * 4225 */ 4226 public void setAny(Object value) { 4227 this.any = value; 4228 } 4229 4230 public String toString() { 4231 final ToStringStrategy strategy = JAXBToStringStrategy.INSTANCE; 4232 final StringBuilder buffer = new StringBuilder(); 4233 append(null, buffer, strategy); 4234 return buffer.toString(); 4235 } 4236 4237 public StringBuilder append(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 4238 strategy.appendStart(locator, this, buffer); 4239 appendFields(locator, buffer, strategy); 4240 strategy.appendEnd(locator, this, buffer); 4241 return buffer; 4242 } 4243 4244 public StringBuilder appendFields(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 4245 { 4246 DtoSystemUsage theSystemUsage; 4247 theSystemUsage = this.getSystemUsage(); 4248 strategy.appendField(locator, this, "systemUsage", buffer, theSystemUsage); 4249 } 4250 { 4251 Object theAny; 4252 theAny = this.getAny(); 4253 strategy.appendField(locator, this, "any", buffer, theAny); 4254 } 4255 return buffer; 4256 } 4257 4258 public int hashCode(ObjectLocator locator, HashCodeStrategy strategy) { 4259 int currentHashCode = 1; 4260 { 4261 DtoSystemUsage theSystemUsage; 4262 theSystemUsage = this.getSystemUsage(); 4263 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "systemUsage", theSystemUsage), currentHashCode, theSystemUsage); 4264 } 4265 { 4266 Object theAny; 4267 theAny = this.getAny(); 4268 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "any", theAny), currentHashCode, theAny); 4269 } 4270 return currentHashCode; 4271 } 4272 4273 public int hashCode() { 4274 final HashCodeStrategy strategy = JAXBHashCodeStrategy.INSTANCE; 4275 return this.hashCode(null, strategy); 4276 } 4277 4278 public boolean equals(ObjectLocator thisLocator, ObjectLocator thatLocator, Object object, EqualsStrategy strategy) { 4279 if (!(object instanceof DtoJdbcPersistenceAdapter.UsageManager)) { 4280 return false; 4281 } 4282 if (this == object) { 4283 return true; 4284 } 4285 final DtoJdbcPersistenceAdapter.UsageManager that = ((DtoJdbcPersistenceAdapter.UsageManager) object); 4286 { 4287 DtoSystemUsage lhsSystemUsage; 4288 lhsSystemUsage = this.getSystemUsage(); 4289 DtoSystemUsage rhsSystemUsage; 4290 rhsSystemUsage = that.getSystemUsage(); 4291 if (!strategy.equals(LocatorUtils.property(thisLocator, "systemUsage", lhsSystemUsage), LocatorUtils.property(thatLocator, "systemUsage", rhsSystemUsage), lhsSystemUsage, rhsSystemUsage)) { 4292 return false; 4293 } 4294 } 4295 { 4296 Object lhsAny; 4297 lhsAny = this.getAny(); 4298 Object rhsAny; 4299 rhsAny = that.getAny(); 4300 if (!strategy.equals(LocatorUtils.property(thisLocator, "any", lhsAny), LocatorUtils.property(thatLocator, "any", rhsAny), lhsAny, rhsAny)) { 4301 return false; 4302 } 4303 } 4304 return true; 4305 } 4306 4307 public boolean equals(Object object) { 4308 final EqualsStrategy strategy = new org.apache.activemq.plugin.jaxb2_commons.ElementAwareEqualsStrategy(); 4309 return equals(null, null, object, strategy); 4310 } 4311 4312 } 4313 4314 4315 /** 4316 * <p>Java class for anonymous complex type. 4317 * 4318 * <p>The following schema fragment specifies the expected content contained within this class. 4319 * 4320 * <pre> 4321 * <complexType> 4322 * <complexContent> 4323 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 4324 * <sequence minOccurs="0"> 4325 * <any maxOccurs="unbounded" minOccurs="0"/> 4326 * </sequence> 4327 * </restriction> 4328 * </complexContent> 4329 * </complexType> 4330 * </pre> 4331 * 4332 * 4333 */ 4334 @XmlAccessorType(XmlAccessType.FIELD) 4335 @XmlType(name = "", propOrder = { 4336 "any" 4337 }) 4338 public static class WireFormat 4339 implements Equals, HashCode, ToString 4340 { 4341 4342 @XmlAnyElement(lax = true) 4343 protected List<Object> any; 4344 4345 /** 4346 * Gets the value of the any property. 4347 * 4348 * <p> 4349 * This accessor method returns a reference to the live list, 4350 * not a snapshot. Therefore any modification you make to the 4351 * returned list will be present inside the JAXB object. 4352 * This is why there is not a <CODE>set</CODE> method for the any property. 4353 * 4354 * <p> 4355 * For example, to add a new item, do as follows: 4356 * <pre> 4357 * getAny().add(newItem); 4358 * </pre> 4359 * 4360 * 4361 * <p> 4362 * Objects of the following type(s) are allowed in the list 4363 * {@link Object } 4364 * 4365 * 4366 */ 4367 public List<Object> getAny() { 4368 if (any == null) { 4369 any = new ArrayList<Object>(); 4370 } 4371 return this.any; 4372 } 4373 4374 public String toString() { 4375 final ToStringStrategy strategy = JAXBToStringStrategy.INSTANCE; 4376 final StringBuilder buffer = new StringBuilder(); 4377 append(null, buffer, strategy); 4378 return buffer.toString(); 4379 } 4380 4381 public StringBuilder append(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 4382 strategy.appendStart(locator, this, buffer); 4383 appendFields(locator, buffer, strategy); 4384 strategy.appendEnd(locator, this, buffer); 4385 return buffer; 4386 } 4387 4388 public StringBuilder appendFields(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 4389 { 4390 List<Object> theAny; 4391 theAny = (((this.any!= null)&&(!this.any.isEmpty()))?this.getAny():null); 4392 strategy.appendField(locator, this, "any", buffer, theAny); 4393 } 4394 return buffer; 4395 } 4396 4397 public int hashCode(ObjectLocator locator, HashCodeStrategy strategy) { 4398 int currentHashCode = 1; 4399 { 4400 List<Object> theAny; 4401 theAny = (((this.any!= null)&&(!this.any.isEmpty()))?this.getAny():null); 4402 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "any", theAny), currentHashCode, theAny); 4403 } 4404 return currentHashCode; 4405 } 4406 4407 public int hashCode() { 4408 final HashCodeStrategy strategy = JAXBHashCodeStrategy.INSTANCE; 4409 return this.hashCode(null, strategy); 4410 } 4411 4412 public boolean equals(ObjectLocator thisLocator, ObjectLocator thatLocator, Object object, EqualsStrategy strategy) { 4413 if (!(object instanceof DtoJdbcPersistenceAdapter.WireFormat)) { 4414 return false; 4415 } 4416 if (this == object) { 4417 return true; 4418 } 4419 final DtoJdbcPersistenceAdapter.WireFormat that = ((DtoJdbcPersistenceAdapter.WireFormat) object); 4420 { 4421 List<Object> lhsAny; 4422 lhsAny = (((this.any!= null)&&(!this.any.isEmpty()))?this.getAny():null); 4423 List<Object> rhsAny; 4424 rhsAny = (((that.any!= null)&&(!that.any.isEmpty()))?that.getAny():null); 4425 if (!strategy.equals(LocatorUtils.property(thisLocator, "any", lhsAny), LocatorUtils.property(thatLocator, "any", rhsAny), lhsAny, rhsAny)) { 4426 return false; 4427 } 4428 } 4429 return true; 4430 } 4431 4432 public boolean equals(Object object) { 4433 final EqualsStrategy strategy = new org.apache.activemq.plugin.jaxb2_commons.ElementAwareEqualsStrategy(); 4434 return equals(null, null, object, strategy); 4435 } 4436 4437 } 4438 4439}