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: 2017.07.25 at 01:05:24 PM EDT 006// 007 008 009package org.apache.activemq.schema.core; 010 011import java.math.BigInteger; 012import java.util.ArrayList; 013import java.util.HashMap; 014import java.util.List; 015import java.util.Map; 016import javax.xml.bind.JAXBElement; 017import javax.xml.bind.annotation.XmlAccessType; 018import javax.xml.bind.annotation.XmlAccessorType; 019import javax.xml.bind.annotation.XmlAnyAttribute; 020import javax.xml.bind.annotation.XmlAnyElement; 021import javax.xml.bind.annotation.XmlAttribute; 022import javax.xml.bind.annotation.XmlElementRef; 023import javax.xml.bind.annotation.XmlElementRefs; 024import javax.xml.bind.annotation.XmlID; 025import javax.xml.bind.annotation.XmlRootElement; 026import javax.xml.bind.annotation.XmlSchemaType; 027import javax.xml.bind.annotation.XmlType; 028import javax.xml.bind.annotation.adapters.CollapsedStringAdapter; 029import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter; 030import javax.xml.namespace.QName; 031import org.jvnet.jaxb2_commons.lang.Equals; 032import org.jvnet.jaxb2_commons.lang.EqualsStrategy; 033import org.jvnet.jaxb2_commons.lang.HashCode; 034import org.jvnet.jaxb2_commons.lang.HashCodeStrategy; 035import org.jvnet.jaxb2_commons.lang.JAXBHashCodeStrategy; 036import org.jvnet.jaxb2_commons.lang.JAXBToStringStrategy; 037import org.jvnet.jaxb2_commons.lang.ToString; 038import org.jvnet.jaxb2_commons.lang.ToStringStrategy; 039import org.jvnet.jaxb2_commons.locator.ObjectLocator; 040import org.jvnet.jaxb2_commons.locator.util.LocatorUtils; 041 042 043/** 044 * <p>Java class for anonymous complex type. 045 * 046 * <p>The following schema fragment specifies the expected content contained within this class. 047 * 048 * <pre> 049 * <complexType> 050 * <complexContent> 051 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 052 * <choice maxOccurs="unbounded" minOccurs="0"> 053 * <choice> 054 * <element name="executor" minOccurs="0"> 055 * <complexType> 056 * <complexContent> 057 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 058 * <sequence minOccurs="0"> 059 * <any maxOccurs="unbounded" minOccurs="0"/> 060 * </sequence> 061 * </restriction> 062 * </complexContent> 063 * </complexType> 064 * </element> 065 * <element name="limiter" minOccurs="0"> 066 * <complexType> 067 * <complexContent> 068 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 069 * <choice minOccurs="0"> 070 * <element ref="{http://activemq.apache.org/schema/core}defaultUsageCapacity"/> 071 * <element ref="{http://activemq.apache.org/schema/core}usageCapacity"/> 072 * <any namespace='##other'/> 073 * </choice> 074 * </restriction> 075 * </complexContent> 076 * </complexType> 077 * </element> 078 * <element name="parent" minOccurs="0"> 079 * <complexType> 080 * <complexContent> 081 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 082 * <sequence minOccurs="0"> 083 * <any maxOccurs="unbounded" minOccurs="0"/> 084 * </sequence> 085 * </restriction> 086 * </complexContent> 087 * </complexType> 088 * </element> 089 * <any namespace='##other' maxOccurs="unbounded" minOccurs="0"/> 090 * </choice> 091 * </choice> 092 * <attribute name="executor" type="{http://www.w3.org/2001/XMLSchema}string" /> 093 * <attribute name="limit" type="{http://www.w3.org/2001/XMLSchema}string" /> 094 * <attribute name="limiter" type="{http://www.w3.org/2001/XMLSchema}string" /> 095 * <attribute name="name" type="{http://www.w3.org/2001/XMLSchema}string" /> 096 * <attribute name="parent" type="{http://www.w3.org/2001/XMLSchema}string" /> 097 * <attribute name="percentOfJvmHeap" type="{http://www.w3.org/2001/XMLSchema}integer" /> 098 * <attribute name="percentUsage" type="{http://www.w3.org/2001/XMLSchema}integer" /> 099 * <attribute name="percentUsageMinDelta" type="{http://www.w3.org/2001/XMLSchema}string" /> 100 * <attribute name="pollingTime" type="{http://www.w3.org/2001/XMLSchema}integer" /> 101 * <attribute name="portion" type="{http://www.w3.org/2001/XMLSchema}float" /> 102 * <attribute name="usage" type="{http://www.w3.org/2001/XMLSchema}long" /> 103 * <attribute name="usagePortion" type="{http://www.w3.org/2001/XMLSchema}float" /> 104 * <attribute name="id" type="{http://www.w3.org/2001/XMLSchema}ID" /> 105 * <anyAttribute processContents='lax' namespace='##other'/> 106 * </restriction> 107 * </complexContent> 108 * </complexType> 109 * </pre> 110 * 111 * 112 */ 113@XmlAccessorType(XmlAccessType.FIELD) 114@XmlType(name = "", propOrder = { 115 "executorOrLimiterOrParent" 116}) 117@XmlRootElement(name = "memoryUsage") 118public class DtoMemoryUsage implements Equals, HashCode, ToString 119{ 120 121 @XmlElementRefs({ 122 @XmlElementRef(name = "executor", namespace = "http://activemq.apache.org/schema/core", type = JAXBElement.class, required = false), 123 @XmlElementRef(name = "parent", namespace = "http://activemq.apache.org/schema/core", type = JAXBElement.class, required = false), 124 @XmlElementRef(name = "limiter", namespace = "http://activemq.apache.org/schema/core", type = JAXBElement.class, required = false) 125 }) 126 @XmlAnyElement(lax = true) 127 protected List<Object> executorOrLimiterOrParent; 128 @XmlAttribute(name = "executor") 129 protected String executor; 130 @XmlAttribute(name = "limit") 131 protected String limit; 132 @XmlAttribute(name = "limiter") 133 protected String limiter; 134 @XmlAttribute(name = "name") 135 protected String name; 136 @XmlAttribute(name = "parent") 137 protected String parent; 138 @XmlAttribute(name = "percentOfJvmHeap") 139 protected BigInteger percentOfJvmHeap; 140 @XmlAttribute(name = "percentUsage") 141 protected BigInteger percentUsage; 142 @XmlAttribute(name = "percentUsageMinDelta") 143 protected String percentUsageMinDelta; 144 @XmlAttribute(name = "pollingTime") 145 protected BigInteger pollingTime; 146 @XmlAttribute(name = "portion") 147 protected Float portion; 148 @XmlAttribute(name = "usage") 149 protected Long usage; 150 @XmlAttribute(name = "usagePortion") 151 protected Float usagePortion; 152 @XmlAttribute(name = "id") 153 @XmlJavaTypeAdapter(CollapsedStringAdapter.class) 154 @XmlID 155 @XmlSchemaType(name = "ID") 156 protected String id; 157 @XmlAnyAttribute 158 private Map<QName, String> otherAttributes = new HashMap<QName, String>(); 159 160 /** 161 * Gets the value of the executorOrLimiterOrParent property. 162 * 163 * <p> 164 * This accessor method returns a reference to the live list, 165 * not a snapshot. Therefore any modification you make to the 166 * returned list will be present inside the JAXB object. 167 * This is why there is not a <CODE>set</CODE> method for the executorOrLimiterOrParent property. 168 * 169 * <p> 170 * For example, to add a new item, do as follows: 171 * <pre> 172 * getExecutorOrLimiterOrParent().add(newItem); 173 * </pre> 174 * 175 * 176 * <p> 177 * Objects of the following type(s) are allowed in the list 178 * {@link JAXBElement }{@code <}{@link DtoMemoryUsage.Limiter }{@code >} 179 * {@link JAXBElement }{@code <}{@link DtoMemoryUsage.Parent }{@code >} 180 * {@link Object } 181 * {@link JAXBElement }{@code <}{@link DtoMemoryUsage.Executor }{@code >} 182 * 183 * 184 */ 185 public List<Object> getExecutorOrLimiterOrParent() { 186 if (executorOrLimiterOrParent == null) { 187 executorOrLimiterOrParent = new ArrayList<Object>(); 188 } 189 return this.executorOrLimiterOrParent; 190 } 191 192 /** 193 * Gets the value of the executor property. 194 * 195 * @return 196 * possible object is 197 * {@link String } 198 * 199 */ 200 public String getExecutor() { 201 return executor; 202 } 203 204 /** 205 * Sets the value of the executor property. 206 * 207 * @param value 208 * allowed object is 209 * {@link String } 210 * 211 */ 212 public void setExecutor(String value) { 213 this.executor = value; 214 } 215 216 /** 217 * Gets the value of the limit property. 218 * 219 * @return 220 * possible object is 221 * {@link String } 222 * 223 */ 224 public String getLimit() { 225 return limit; 226 } 227 228 /** 229 * Sets the value of the limit property. 230 * 231 * @param value 232 * allowed object is 233 * {@link String } 234 * 235 */ 236 public void setLimit(String value) { 237 this.limit = value; 238 } 239 240 /** 241 * Gets the value of the limiter property. 242 * 243 * @return 244 * possible object is 245 * {@link String } 246 * 247 */ 248 public String getLimiter() { 249 return limiter; 250 } 251 252 /** 253 * Sets the value of the limiter property. 254 * 255 * @param value 256 * allowed object is 257 * {@link String } 258 * 259 */ 260 public void setLimiter(String value) { 261 this.limiter = value; 262 } 263 264 /** 265 * Gets the value of the name property. 266 * 267 * @return 268 * possible object is 269 * {@link String } 270 * 271 */ 272 public String getName() { 273 return name; 274 } 275 276 /** 277 * Sets the value of the name property. 278 * 279 * @param value 280 * allowed object is 281 * {@link String } 282 * 283 */ 284 public void setName(String value) { 285 this.name = value; 286 } 287 288 /** 289 * Gets the value of the parent property. 290 * 291 * @return 292 * possible object is 293 * {@link String } 294 * 295 */ 296 public String getParent() { 297 return parent; 298 } 299 300 /** 301 * Sets the value of the parent property. 302 * 303 * @param value 304 * allowed object is 305 * {@link String } 306 * 307 */ 308 public void setParent(String value) { 309 this.parent = value; 310 } 311 312 /** 313 * Gets the value of the percentOfJvmHeap property. 314 * 315 * @return 316 * possible object is 317 * {@link BigInteger } 318 * 319 */ 320 public BigInteger getPercentOfJvmHeap() { 321 return percentOfJvmHeap; 322 } 323 324 /** 325 * Sets the value of the percentOfJvmHeap property. 326 * 327 * @param value 328 * allowed object is 329 * {@link BigInteger } 330 * 331 */ 332 public void setPercentOfJvmHeap(BigInteger value) { 333 this.percentOfJvmHeap = value; 334 } 335 336 /** 337 * Gets the value of the percentUsage property. 338 * 339 * @return 340 * possible object is 341 * {@link BigInteger } 342 * 343 */ 344 public BigInteger getPercentUsage() { 345 return percentUsage; 346 } 347 348 /** 349 * Sets the value of the percentUsage property. 350 * 351 * @param value 352 * allowed object is 353 * {@link BigInteger } 354 * 355 */ 356 public void setPercentUsage(BigInteger value) { 357 this.percentUsage = value; 358 } 359 360 /** 361 * Gets the value of the percentUsageMinDelta property. 362 * 363 * @return 364 * possible object is 365 * {@link String } 366 * 367 */ 368 public String getPercentUsageMinDelta() { 369 return percentUsageMinDelta; 370 } 371 372 /** 373 * Sets the value of the percentUsageMinDelta property. 374 * 375 * @param value 376 * allowed object is 377 * {@link String } 378 * 379 */ 380 public void setPercentUsageMinDelta(String value) { 381 this.percentUsageMinDelta = value; 382 } 383 384 /** 385 * Gets the value of the pollingTime property. 386 * 387 * @return 388 * possible object is 389 * {@link BigInteger } 390 * 391 */ 392 public BigInteger getPollingTime() { 393 return pollingTime; 394 } 395 396 /** 397 * Sets the value of the pollingTime property. 398 * 399 * @param value 400 * allowed object is 401 * {@link BigInteger } 402 * 403 */ 404 public void setPollingTime(BigInteger value) { 405 this.pollingTime = value; 406 } 407 408 /** 409 * Gets the value of the portion property. 410 * 411 * @return 412 * possible object is 413 * {@link Float } 414 * 415 */ 416 public Float getPortion() { 417 return portion; 418 } 419 420 /** 421 * Sets the value of the portion property. 422 * 423 * @param value 424 * allowed object is 425 * {@link Float } 426 * 427 */ 428 public void setPortion(Float value) { 429 this.portion = value; 430 } 431 432 /** 433 * Gets the value of the usage property. 434 * 435 * @return 436 * possible object is 437 * {@link Long } 438 * 439 */ 440 public Long getUsage() { 441 return usage; 442 } 443 444 /** 445 * Sets the value of the usage property. 446 * 447 * @param value 448 * allowed object is 449 * {@link Long } 450 * 451 */ 452 public void setUsage(Long value) { 453 this.usage = value; 454 } 455 456 /** 457 * Gets the value of the usagePortion property. 458 * 459 * @return 460 * possible object is 461 * {@link Float } 462 * 463 */ 464 public Float getUsagePortion() { 465 return usagePortion; 466 } 467 468 /** 469 * Sets the value of the usagePortion property. 470 * 471 * @param value 472 * allowed object is 473 * {@link Float } 474 * 475 */ 476 public void setUsagePortion(Float value) { 477 this.usagePortion = value; 478 } 479 480 /** 481 * Gets the value of the id property. 482 * 483 * @return 484 * possible object is 485 * {@link String } 486 * 487 */ 488 public String getId() { 489 return id; 490 } 491 492 /** 493 * Sets the value of the id property. 494 * 495 * @param value 496 * allowed object is 497 * {@link String } 498 * 499 */ 500 public void setId(String value) { 501 this.id = value; 502 } 503 504 /** 505 * Gets a map that contains attributes that aren't bound to any typed property on this class. 506 * 507 * <p> 508 * the map is keyed by the name of the attribute and 509 * the value is the string value of the attribute. 510 * 511 * the map returned by this method is live, and you can add new attribute 512 * by updating the map directly. Because of this design, there's no setter. 513 * 514 * 515 * @return 516 * always non-null 517 */ 518 public Map<QName, String> getOtherAttributes() { 519 return otherAttributes; 520 } 521 522 public String toString() { 523 final ToStringStrategy strategy = JAXBToStringStrategy.INSTANCE; 524 final StringBuilder buffer = new StringBuilder(); 525 append(null, buffer, strategy); 526 return buffer.toString(); 527 } 528 529 public StringBuilder append(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 530 strategy.appendStart(locator, this, buffer); 531 appendFields(locator, buffer, strategy); 532 strategy.appendEnd(locator, this, buffer); 533 return buffer; 534 } 535 536 public StringBuilder appendFields(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 537 { 538 List<Object> theExecutorOrLimiterOrParent; 539 theExecutorOrLimiterOrParent = (((this.executorOrLimiterOrParent!= null)&&(!this.executorOrLimiterOrParent.isEmpty()))?this.getExecutorOrLimiterOrParent():null); 540 strategy.appendField(locator, this, "executorOrLimiterOrParent", buffer, theExecutorOrLimiterOrParent); 541 } 542 { 543 String theExecutor; 544 theExecutor = this.getExecutor(); 545 strategy.appendField(locator, this, "executor", buffer, theExecutor); 546 } 547 { 548 String theLimit; 549 theLimit = this.getLimit(); 550 strategy.appendField(locator, this, "limit", buffer, theLimit); 551 } 552 { 553 String theLimiter; 554 theLimiter = this.getLimiter(); 555 strategy.appendField(locator, this, "limiter", buffer, theLimiter); 556 } 557 { 558 String theName; 559 theName = this.getName(); 560 strategy.appendField(locator, this, "name", buffer, theName); 561 } 562 { 563 String theParent; 564 theParent = this.getParent(); 565 strategy.appendField(locator, this, "parent", buffer, theParent); 566 } 567 { 568 BigInteger thePercentOfJvmHeap; 569 thePercentOfJvmHeap = this.getPercentOfJvmHeap(); 570 strategy.appendField(locator, this, "percentOfJvmHeap", buffer, thePercentOfJvmHeap); 571 } 572 { 573 BigInteger thePercentUsage; 574 thePercentUsage = this.getPercentUsage(); 575 strategy.appendField(locator, this, "percentUsage", buffer, thePercentUsage); 576 } 577 { 578 String thePercentUsageMinDelta; 579 thePercentUsageMinDelta = this.getPercentUsageMinDelta(); 580 strategy.appendField(locator, this, "percentUsageMinDelta", buffer, thePercentUsageMinDelta); 581 } 582 { 583 BigInteger thePollingTime; 584 thePollingTime = this.getPollingTime(); 585 strategy.appendField(locator, this, "pollingTime", buffer, thePollingTime); 586 } 587 { 588 Float thePortion; 589 thePortion = this.getPortion(); 590 strategy.appendField(locator, this, "portion", buffer, thePortion); 591 } 592 { 593 Long theUsage; 594 theUsage = this.getUsage(); 595 strategy.appendField(locator, this, "usage", buffer, theUsage); 596 } 597 { 598 Float theUsagePortion; 599 theUsagePortion = this.getUsagePortion(); 600 strategy.appendField(locator, this, "usagePortion", buffer, theUsagePortion); 601 } 602 { 603 String theId; 604 theId = this.getId(); 605 strategy.appendField(locator, this, "id", buffer, theId); 606 } 607 return buffer; 608 } 609 610 public int hashCode(ObjectLocator locator, HashCodeStrategy strategy) { 611 int currentHashCode = 1; 612 { 613 List<Object> theExecutorOrLimiterOrParent; 614 theExecutorOrLimiterOrParent = (((this.executorOrLimiterOrParent!= null)&&(!this.executorOrLimiterOrParent.isEmpty()))?this.getExecutorOrLimiterOrParent():null); 615 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "executorOrLimiterOrParent", theExecutorOrLimiterOrParent), currentHashCode, theExecutorOrLimiterOrParent); 616 } 617 { 618 String theExecutor; 619 theExecutor = this.getExecutor(); 620 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "executor", theExecutor), currentHashCode, theExecutor); 621 } 622 { 623 String theLimit; 624 theLimit = this.getLimit(); 625 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "limit", theLimit), currentHashCode, theLimit); 626 } 627 { 628 String theLimiter; 629 theLimiter = this.getLimiter(); 630 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "limiter", theLimiter), currentHashCode, theLimiter); 631 } 632 { 633 String theName; 634 theName = this.getName(); 635 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "name", theName), currentHashCode, theName); 636 } 637 { 638 String theParent; 639 theParent = this.getParent(); 640 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "parent", theParent), currentHashCode, theParent); 641 } 642 { 643 BigInteger thePercentOfJvmHeap; 644 thePercentOfJvmHeap = this.getPercentOfJvmHeap(); 645 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "percentOfJvmHeap", thePercentOfJvmHeap), currentHashCode, thePercentOfJvmHeap); 646 } 647 { 648 BigInteger thePercentUsage; 649 thePercentUsage = this.getPercentUsage(); 650 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "percentUsage", thePercentUsage), currentHashCode, thePercentUsage); 651 } 652 { 653 String thePercentUsageMinDelta; 654 thePercentUsageMinDelta = this.getPercentUsageMinDelta(); 655 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "percentUsageMinDelta", thePercentUsageMinDelta), currentHashCode, thePercentUsageMinDelta); 656 } 657 { 658 BigInteger thePollingTime; 659 thePollingTime = this.getPollingTime(); 660 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "pollingTime", thePollingTime), currentHashCode, thePollingTime); 661 } 662 { 663 Float thePortion; 664 thePortion = this.getPortion(); 665 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "portion", thePortion), currentHashCode, thePortion); 666 } 667 { 668 Long theUsage; 669 theUsage = this.getUsage(); 670 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "usage", theUsage), currentHashCode, theUsage); 671 } 672 { 673 Float theUsagePortion; 674 theUsagePortion = this.getUsagePortion(); 675 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "usagePortion", theUsagePortion), currentHashCode, theUsagePortion); 676 } 677 { 678 String theId; 679 theId = this.getId(); 680 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "id", theId), currentHashCode, theId); 681 } 682 return currentHashCode; 683 } 684 685 public int hashCode() { 686 final HashCodeStrategy strategy = JAXBHashCodeStrategy.INSTANCE; 687 return this.hashCode(null, strategy); 688 } 689 690 public boolean equals(ObjectLocator thisLocator, ObjectLocator thatLocator, Object object, EqualsStrategy strategy) { 691 if (!(object instanceof DtoMemoryUsage)) { 692 return false; 693 } 694 if (this == object) { 695 return true; 696 } 697 final DtoMemoryUsage that = ((DtoMemoryUsage) object); 698 { 699 List<Object> lhsExecutorOrLimiterOrParent; 700 lhsExecutorOrLimiterOrParent = (((this.executorOrLimiterOrParent!= null)&&(!this.executorOrLimiterOrParent.isEmpty()))?this.getExecutorOrLimiterOrParent():null); 701 List<Object> rhsExecutorOrLimiterOrParent; 702 rhsExecutorOrLimiterOrParent = (((that.executorOrLimiterOrParent!= null)&&(!that.executorOrLimiterOrParent.isEmpty()))?that.getExecutorOrLimiterOrParent():null); 703 if (!strategy.equals(LocatorUtils.property(thisLocator, "executorOrLimiterOrParent", lhsExecutorOrLimiterOrParent), LocatorUtils.property(thatLocator, "executorOrLimiterOrParent", rhsExecutorOrLimiterOrParent), lhsExecutorOrLimiterOrParent, rhsExecutorOrLimiterOrParent)) { 704 return false; 705 } 706 } 707 { 708 String lhsExecutor; 709 lhsExecutor = this.getExecutor(); 710 String rhsExecutor; 711 rhsExecutor = that.getExecutor(); 712 if (!strategy.equals(LocatorUtils.property(thisLocator, "executor", lhsExecutor), LocatorUtils.property(thatLocator, "executor", rhsExecutor), lhsExecutor, rhsExecutor)) { 713 return false; 714 } 715 } 716 { 717 String lhsLimit; 718 lhsLimit = this.getLimit(); 719 String rhsLimit; 720 rhsLimit = that.getLimit(); 721 if (!strategy.equals(LocatorUtils.property(thisLocator, "limit", lhsLimit), LocatorUtils.property(thatLocator, "limit", rhsLimit), lhsLimit, rhsLimit)) { 722 return false; 723 } 724 } 725 { 726 String lhsLimiter; 727 lhsLimiter = this.getLimiter(); 728 String rhsLimiter; 729 rhsLimiter = that.getLimiter(); 730 if (!strategy.equals(LocatorUtils.property(thisLocator, "limiter", lhsLimiter), LocatorUtils.property(thatLocator, "limiter", rhsLimiter), lhsLimiter, rhsLimiter)) { 731 return false; 732 } 733 } 734 { 735 String lhsName; 736 lhsName = this.getName(); 737 String rhsName; 738 rhsName = that.getName(); 739 if (!strategy.equals(LocatorUtils.property(thisLocator, "name", lhsName), LocatorUtils.property(thatLocator, "name", rhsName), lhsName, rhsName)) { 740 return false; 741 } 742 } 743 { 744 String lhsParent; 745 lhsParent = this.getParent(); 746 String rhsParent; 747 rhsParent = that.getParent(); 748 if (!strategy.equals(LocatorUtils.property(thisLocator, "parent", lhsParent), LocatorUtils.property(thatLocator, "parent", rhsParent), lhsParent, rhsParent)) { 749 return false; 750 } 751 } 752 { 753 BigInteger lhsPercentOfJvmHeap; 754 lhsPercentOfJvmHeap = this.getPercentOfJvmHeap(); 755 BigInteger rhsPercentOfJvmHeap; 756 rhsPercentOfJvmHeap = that.getPercentOfJvmHeap(); 757 if (!strategy.equals(LocatorUtils.property(thisLocator, "percentOfJvmHeap", lhsPercentOfJvmHeap), LocatorUtils.property(thatLocator, "percentOfJvmHeap", rhsPercentOfJvmHeap), lhsPercentOfJvmHeap, rhsPercentOfJvmHeap)) { 758 return false; 759 } 760 } 761 { 762 BigInteger lhsPercentUsage; 763 lhsPercentUsage = this.getPercentUsage(); 764 BigInteger rhsPercentUsage; 765 rhsPercentUsage = that.getPercentUsage(); 766 if (!strategy.equals(LocatorUtils.property(thisLocator, "percentUsage", lhsPercentUsage), LocatorUtils.property(thatLocator, "percentUsage", rhsPercentUsage), lhsPercentUsage, rhsPercentUsage)) { 767 return false; 768 } 769 } 770 { 771 String lhsPercentUsageMinDelta; 772 lhsPercentUsageMinDelta = this.getPercentUsageMinDelta(); 773 String rhsPercentUsageMinDelta; 774 rhsPercentUsageMinDelta = that.getPercentUsageMinDelta(); 775 if (!strategy.equals(LocatorUtils.property(thisLocator, "percentUsageMinDelta", lhsPercentUsageMinDelta), LocatorUtils.property(thatLocator, "percentUsageMinDelta", rhsPercentUsageMinDelta), lhsPercentUsageMinDelta, rhsPercentUsageMinDelta)) { 776 return false; 777 } 778 } 779 { 780 BigInteger lhsPollingTime; 781 lhsPollingTime = this.getPollingTime(); 782 BigInteger rhsPollingTime; 783 rhsPollingTime = that.getPollingTime(); 784 if (!strategy.equals(LocatorUtils.property(thisLocator, "pollingTime", lhsPollingTime), LocatorUtils.property(thatLocator, "pollingTime", rhsPollingTime), lhsPollingTime, rhsPollingTime)) { 785 return false; 786 } 787 } 788 { 789 Float lhsPortion; 790 lhsPortion = this.getPortion(); 791 Float rhsPortion; 792 rhsPortion = that.getPortion(); 793 if (!strategy.equals(LocatorUtils.property(thisLocator, "portion", lhsPortion), LocatorUtils.property(thatLocator, "portion", rhsPortion), lhsPortion, rhsPortion)) { 794 return false; 795 } 796 } 797 { 798 Long lhsUsage; 799 lhsUsage = this.getUsage(); 800 Long rhsUsage; 801 rhsUsage = that.getUsage(); 802 if (!strategy.equals(LocatorUtils.property(thisLocator, "usage", lhsUsage), LocatorUtils.property(thatLocator, "usage", rhsUsage), lhsUsage, rhsUsage)) { 803 return false; 804 } 805 } 806 { 807 Float lhsUsagePortion; 808 lhsUsagePortion = this.getUsagePortion(); 809 Float rhsUsagePortion; 810 rhsUsagePortion = that.getUsagePortion(); 811 if (!strategy.equals(LocatorUtils.property(thisLocator, "usagePortion", lhsUsagePortion), LocatorUtils.property(thatLocator, "usagePortion", rhsUsagePortion), lhsUsagePortion, rhsUsagePortion)) { 812 return false; 813 } 814 } 815 { 816 String lhsId; 817 lhsId = this.getId(); 818 String rhsId; 819 rhsId = that.getId(); 820 if (!strategy.equals(LocatorUtils.property(thisLocator, "id", lhsId), LocatorUtils.property(thatLocator, "id", rhsId), lhsId, rhsId)) { 821 return false; 822 } 823 } 824 return true; 825 } 826 827 public boolean equals(Object object) { 828 final EqualsStrategy strategy = new org.apache.activemq.plugin.jaxb2_commons.ElementAwareEqualsStrategy(); 829 return equals(null, null, object, strategy); 830 } 831 832 833 /** 834 * <p>Java class for anonymous complex type. 835 * 836 * <p>The following schema fragment specifies the expected content contained within this class. 837 * 838 * <pre> 839 * <complexType> 840 * <complexContent> 841 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 842 * <sequence minOccurs="0"> 843 * <any maxOccurs="unbounded" minOccurs="0"/> 844 * </sequence> 845 * </restriction> 846 * </complexContent> 847 * </complexType> 848 * </pre> 849 * 850 * 851 */ 852 @XmlAccessorType(XmlAccessType.FIELD) 853 @XmlType(name = "", propOrder = { 854 "any" 855 }) 856 public static class Executor 857 implements Equals, HashCode, ToString 858 { 859 860 @XmlAnyElement(lax = true) 861 protected List<Object> any; 862 863 /** 864 * Gets the value of the any property. 865 * 866 * <p> 867 * This accessor method returns a reference to the live list, 868 * not a snapshot. Therefore any modification you make to the 869 * returned list will be present inside the JAXB object. 870 * This is why there is not a <CODE>set</CODE> method for the any property. 871 * 872 * <p> 873 * For example, to add a new item, do as follows: 874 * <pre> 875 * getAny().add(newItem); 876 * </pre> 877 * 878 * 879 * <p> 880 * Objects of the following type(s) are allowed in the list 881 * {@link Object } 882 * 883 * 884 */ 885 public List<Object> getAny() { 886 if (any == null) { 887 any = new ArrayList<Object>(); 888 } 889 return this.any; 890 } 891 892 public String toString() { 893 final ToStringStrategy strategy = JAXBToStringStrategy.INSTANCE; 894 final StringBuilder buffer = new StringBuilder(); 895 append(null, buffer, strategy); 896 return buffer.toString(); 897 } 898 899 public StringBuilder append(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 900 strategy.appendStart(locator, this, buffer); 901 appendFields(locator, buffer, strategy); 902 strategy.appendEnd(locator, this, buffer); 903 return buffer; 904 } 905 906 public StringBuilder appendFields(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 907 { 908 List<Object> theAny; 909 theAny = (((this.any!= null)&&(!this.any.isEmpty()))?this.getAny():null); 910 strategy.appendField(locator, this, "any", buffer, theAny); 911 } 912 return buffer; 913 } 914 915 public int hashCode(ObjectLocator locator, HashCodeStrategy strategy) { 916 int currentHashCode = 1; 917 { 918 List<Object> theAny; 919 theAny = (((this.any!= null)&&(!this.any.isEmpty()))?this.getAny():null); 920 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "any", theAny), currentHashCode, theAny); 921 } 922 return currentHashCode; 923 } 924 925 public int hashCode() { 926 final HashCodeStrategy strategy = JAXBHashCodeStrategy.INSTANCE; 927 return this.hashCode(null, strategy); 928 } 929 930 public boolean equals(ObjectLocator thisLocator, ObjectLocator thatLocator, Object object, EqualsStrategy strategy) { 931 if (!(object instanceof DtoMemoryUsage.Executor)) { 932 return false; 933 } 934 if (this == object) { 935 return true; 936 } 937 final DtoMemoryUsage.Executor that = ((DtoMemoryUsage.Executor) object); 938 { 939 List<Object> lhsAny; 940 lhsAny = (((this.any!= null)&&(!this.any.isEmpty()))?this.getAny():null); 941 List<Object> rhsAny; 942 rhsAny = (((that.any!= null)&&(!that.any.isEmpty()))?that.getAny():null); 943 if (!strategy.equals(LocatorUtils.property(thisLocator, "any", lhsAny), LocatorUtils.property(thatLocator, "any", rhsAny), lhsAny, rhsAny)) { 944 return false; 945 } 946 } 947 return true; 948 } 949 950 public boolean equals(Object object) { 951 final EqualsStrategy strategy = new org.apache.activemq.plugin.jaxb2_commons.ElementAwareEqualsStrategy(); 952 return equals(null, null, object, strategy); 953 } 954 955 } 956 957 958 /** 959 * <p>Java class for anonymous complex type. 960 * 961 * <p>The following schema fragment specifies the expected content contained within this class. 962 * 963 * <pre> 964 * <complexType> 965 * <complexContent> 966 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 967 * <choice minOccurs="0"> 968 * <element ref="{http://activemq.apache.org/schema/core}defaultUsageCapacity"/> 969 * <element ref="{http://activemq.apache.org/schema/core}usageCapacity"/> 970 * <any namespace='##other'/> 971 * </choice> 972 * </restriction> 973 * </complexContent> 974 * </complexType> 975 * </pre> 976 * 977 * 978 */ 979 @XmlAccessorType(XmlAccessType.FIELD) 980 @XmlType(name = "", propOrder = { 981 "defaultUsageCapacity", 982 "usageCapacity", 983 "any" 984 }) 985 public static class Limiter 986 implements Equals, HashCode, ToString 987 { 988 989 protected DtoDefaultUsageCapacity defaultUsageCapacity; 990 protected DtoUsageCapacity usageCapacity; 991 @XmlAnyElement(lax = true) 992 protected Object any; 993 994 /** 995 * Gets the value of the defaultUsageCapacity property. 996 * 997 * @return 998 * possible object is 999 * {@link DtoDefaultUsageCapacity } 1000 * 1001 */ 1002 public DtoDefaultUsageCapacity getDefaultUsageCapacity() { 1003 return defaultUsageCapacity; 1004 } 1005 1006 /** 1007 * Sets the value of the defaultUsageCapacity property. 1008 * 1009 * @param value 1010 * allowed object is 1011 * {@link DtoDefaultUsageCapacity } 1012 * 1013 */ 1014 public void setDefaultUsageCapacity(DtoDefaultUsageCapacity value) { 1015 this.defaultUsageCapacity = value; 1016 } 1017 1018 /** 1019 * Gets the value of the usageCapacity property. 1020 * 1021 * @return 1022 * possible object is 1023 * {@link DtoUsageCapacity } 1024 * 1025 */ 1026 public DtoUsageCapacity getUsageCapacity() { 1027 return usageCapacity; 1028 } 1029 1030 /** 1031 * Sets the value of the usageCapacity property. 1032 * 1033 * @param value 1034 * allowed object is 1035 * {@link DtoUsageCapacity } 1036 * 1037 */ 1038 public void setUsageCapacity(DtoUsageCapacity value) { 1039 this.usageCapacity = value; 1040 } 1041 1042 /** 1043 * Gets the value of the any property. 1044 * 1045 * @return 1046 * possible object is 1047 * {@link Object } 1048 * 1049 */ 1050 public Object getAny() { 1051 return any; 1052 } 1053 1054 /** 1055 * Sets the value of the any property. 1056 * 1057 * @param value 1058 * allowed object is 1059 * {@link Object } 1060 * 1061 */ 1062 public void setAny(Object value) { 1063 this.any = value; 1064 } 1065 1066 public String toString() { 1067 final ToStringStrategy strategy = JAXBToStringStrategy.INSTANCE; 1068 final StringBuilder buffer = new StringBuilder(); 1069 append(null, buffer, strategy); 1070 return buffer.toString(); 1071 } 1072 1073 public StringBuilder append(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 1074 strategy.appendStart(locator, this, buffer); 1075 appendFields(locator, buffer, strategy); 1076 strategy.appendEnd(locator, this, buffer); 1077 return buffer; 1078 } 1079 1080 public StringBuilder appendFields(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 1081 { 1082 DtoDefaultUsageCapacity theDefaultUsageCapacity; 1083 theDefaultUsageCapacity = this.getDefaultUsageCapacity(); 1084 strategy.appendField(locator, this, "defaultUsageCapacity", buffer, theDefaultUsageCapacity); 1085 } 1086 { 1087 DtoUsageCapacity theUsageCapacity; 1088 theUsageCapacity = this.getUsageCapacity(); 1089 strategy.appendField(locator, this, "usageCapacity", buffer, theUsageCapacity); 1090 } 1091 { 1092 Object theAny; 1093 theAny = this.getAny(); 1094 strategy.appendField(locator, this, "any", buffer, theAny); 1095 } 1096 return buffer; 1097 } 1098 1099 public int hashCode(ObjectLocator locator, HashCodeStrategy strategy) { 1100 int currentHashCode = 1; 1101 { 1102 DtoDefaultUsageCapacity theDefaultUsageCapacity; 1103 theDefaultUsageCapacity = this.getDefaultUsageCapacity(); 1104 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "defaultUsageCapacity", theDefaultUsageCapacity), currentHashCode, theDefaultUsageCapacity); 1105 } 1106 { 1107 DtoUsageCapacity theUsageCapacity; 1108 theUsageCapacity = this.getUsageCapacity(); 1109 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "usageCapacity", theUsageCapacity), currentHashCode, theUsageCapacity); 1110 } 1111 { 1112 Object theAny; 1113 theAny = this.getAny(); 1114 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "any", theAny), currentHashCode, theAny); 1115 } 1116 return currentHashCode; 1117 } 1118 1119 public int hashCode() { 1120 final HashCodeStrategy strategy = JAXBHashCodeStrategy.INSTANCE; 1121 return this.hashCode(null, strategy); 1122 } 1123 1124 public boolean equals(ObjectLocator thisLocator, ObjectLocator thatLocator, Object object, EqualsStrategy strategy) { 1125 if (!(object instanceof DtoMemoryUsage.Limiter)) { 1126 return false; 1127 } 1128 if (this == object) { 1129 return true; 1130 } 1131 final DtoMemoryUsage.Limiter that = ((DtoMemoryUsage.Limiter) object); 1132 { 1133 DtoDefaultUsageCapacity lhsDefaultUsageCapacity; 1134 lhsDefaultUsageCapacity = this.getDefaultUsageCapacity(); 1135 DtoDefaultUsageCapacity rhsDefaultUsageCapacity; 1136 rhsDefaultUsageCapacity = that.getDefaultUsageCapacity(); 1137 if (!strategy.equals(LocatorUtils.property(thisLocator, "defaultUsageCapacity", lhsDefaultUsageCapacity), LocatorUtils.property(thatLocator, "defaultUsageCapacity", rhsDefaultUsageCapacity), lhsDefaultUsageCapacity, rhsDefaultUsageCapacity)) { 1138 return false; 1139 } 1140 } 1141 { 1142 DtoUsageCapacity lhsUsageCapacity; 1143 lhsUsageCapacity = this.getUsageCapacity(); 1144 DtoUsageCapacity rhsUsageCapacity; 1145 rhsUsageCapacity = that.getUsageCapacity(); 1146 if (!strategy.equals(LocatorUtils.property(thisLocator, "usageCapacity", lhsUsageCapacity), LocatorUtils.property(thatLocator, "usageCapacity", rhsUsageCapacity), lhsUsageCapacity, rhsUsageCapacity)) { 1147 return false; 1148 } 1149 } 1150 { 1151 Object lhsAny; 1152 lhsAny = this.getAny(); 1153 Object rhsAny; 1154 rhsAny = that.getAny(); 1155 if (!strategy.equals(LocatorUtils.property(thisLocator, "any", lhsAny), LocatorUtils.property(thatLocator, "any", rhsAny), lhsAny, rhsAny)) { 1156 return false; 1157 } 1158 } 1159 return true; 1160 } 1161 1162 public boolean equals(Object object) { 1163 final EqualsStrategy strategy = new org.apache.activemq.plugin.jaxb2_commons.ElementAwareEqualsStrategy(); 1164 return equals(null, null, object, strategy); 1165 } 1166 1167 } 1168 1169 1170 /** 1171 * <p>Java class for anonymous complex type. 1172 * 1173 * <p>The following schema fragment specifies the expected content contained within this class. 1174 * 1175 * <pre> 1176 * <complexType> 1177 * <complexContent> 1178 * <restriction base="{http://www.w3.org/2001/XMLSchema}anyType"> 1179 * <sequence minOccurs="0"> 1180 * <any maxOccurs="unbounded" minOccurs="0"/> 1181 * </sequence> 1182 * </restriction> 1183 * </complexContent> 1184 * </complexType> 1185 * </pre> 1186 * 1187 * 1188 */ 1189 @XmlAccessorType(XmlAccessType.FIELD) 1190 @XmlType(name = "", propOrder = { 1191 "any" 1192 }) 1193 public static class Parent 1194 implements Equals, HashCode, ToString 1195 { 1196 1197 @XmlAnyElement(lax = true) 1198 protected List<Object> any; 1199 1200 /** 1201 * Gets the value of the any property. 1202 * 1203 * <p> 1204 * This accessor method returns a reference to the live list, 1205 * not a snapshot. Therefore any modification you make to the 1206 * returned list will be present inside the JAXB object. 1207 * This is why there is not a <CODE>set</CODE> method for the any property. 1208 * 1209 * <p> 1210 * For example, to add a new item, do as follows: 1211 * <pre> 1212 * getAny().add(newItem); 1213 * </pre> 1214 * 1215 * 1216 * <p> 1217 * Objects of the following type(s) are allowed in the list 1218 * {@link Object } 1219 * 1220 * 1221 */ 1222 public List<Object> getAny() { 1223 if (any == null) { 1224 any = new ArrayList<Object>(); 1225 } 1226 return this.any; 1227 } 1228 1229 public String toString() { 1230 final ToStringStrategy strategy = JAXBToStringStrategy.INSTANCE; 1231 final StringBuilder buffer = new StringBuilder(); 1232 append(null, buffer, strategy); 1233 return buffer.toString(); 1234 } 1235 1236 public StringBuilder append(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 1237 strategy.appendStart(locator, this, buffer); 1238 appendFields(locator, buffer, strategy); 1239 strategy.appendEnd(locator, this, buffer); 1240 return buffer; 1241 } 1242 1243 public StringBuilder appendFields(ObjectLocator locator, StringBuilder buffer, ToStringStrategy strategy) { 1244 { 1245 List<Object> theAny; 1246 theAny = (((this.any!= null)&&(!this.any.isEmpty()))?this.getAny():null); 1247 strategy.appendField(locator, this, "any", buffer, theAny); 1248 } 1249 return buffer; 1250 } 1251 1252 public int hashCode(ObjectLocator locator, HashCodeStrategy strategy) { 1253 int currentHashCode = 1; 1254 { 1255 List<Object> theAny; 1256 theAny = (((this.any!= null)&&(!this.any.isEmpty()))?this.getAny():null); 1257 currentHashCode = strategy.hashCode(LocatorUtils.property(locator, "any", theAny), currentHashCode, theAny); 1258 } 1259 return currentHashCode; 1260 } 1261 1262 public int hashCode() { 1263 final HashCodeStrategy strategy = JAXBHashCodeStrategy.INSTANCE; 1264 return this.hashCode(null, strategy); 1265 } 1266 1267 public boolean equals(ObjectLocator thisLocator, ObjectLocator thatLocator, Object object, EqualsStrategy strategy) { 1268 if (!(object instanceof DtoMemoryUsage.Parent)) { 1269 return false; 1270 } 1271 if (this == object) { 1272 return true; 1273 } 1274 final DtoMemoryUsage.Parent that = ((DtoMemoryUsage.Parent) object); 1275 { 1276 List<Object> lhsAny; 1277 lhsAny = (((this.any!= null)&&(!this.any.isEmpty()))?this.getAny():null); 1278 List<Object> rhsAny; 1279 rhsAny = (((that.any!= null)&&(!that.any.isEmpty()))?that.getAny():null); 1280 if (!strategy.equals(LocatorUtils.property(thisLocator, "any", lhsAny), LocatorUtils.property(thatLocator, "any", rhsAny), lhsAny, rhsAny)) { 1281 return false; 1282 } 1283 } 1284 return true; 1285 } 1286 1287 public boolean equals(Object object) { 1288 final EqualsStrategy strategy = new org.apache.activemq.plugin.jaxb2_commons.ElementAwareEqualsStrategy(); 1289 return equals(null, null, object, strategy); 1290 } 1291 1292 } 1293 1294}