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