1 /* 2 * Copyright (C) 2017 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package android.location.cts.asn1.supl2.rrlp_components; 18 19 /* 20 */ 21 22 23 // 24 // 25 import android.location.cts.asn1.base.Asn1Boolean; 26 import android.location.cts.asn1.base.Asn1Integer; 27 import android.location.cts.asn1.base.Asn1Null; 28 import android.location.cts.asn1.base.Asn1Object; 29 import android.location.cts.asn1.base.Asn1Sequence; 30 import android.location.cts.asn1.base.Asn1Tag; 31 import android.location.cts.asn1.base.BitStream; 32 import android.location.cts.asn1.base.BitStreamReader; 33 import android.location.cts.asn1.base.SequenceComponent; 34 import com.google.common.collect.ImmutableList; 35 import java.util.Collection; 36 import javax.annotation.Nullable; 37 38 39 /** 40 */ 41 public class Almanac_ReducedKeplerianSet extends Asn1Sequence { 42 // 43 44 private static final Asn1Tag TAG_Almanac_ReducedKeplerianSet 45 = Asn1Tag.fromClassAndNumber(-1, -1); 46 47 public Almanac_ReducedKeplerianSet() { 48 super(); 49 } 50 51 @Override 52 @Nullable 53 protected Asn1Tag getTag() { 54 return TAG_Almanac_ReducedKeplerianSet; 55 } 56 57 @Override 58 protected boolean isTagImplicit() { 59 return true; 60 } 61 62 public static Collection<Asn1Tag> getPossibleFirstTags() { 63 if (TAG_Almanac_ReducedKeplerianSet != null) { 64 return ImmutableList.of(TAG_Almanac_ReducedKeplerianSet); 65 } else { 66 return Asn1Sequence.getPossibleFirstTags(); 67 } 68 } 69 70 /** 71 * Creates a new Almanac_ReducedKeplerianSet from encoded stream. 72 */ 73 public static Almanac_ReducedKeplerianSet fromPerUnaligned(byte[] encodedBytes) { 74 Almanac_ReducedKeplerianSet result = new Almanac_ReducedKeplerianSet(); 75 result.decodePerUnaligned(new BitStreamReader(encodedBytes)); 76 return result; 77 } 78 79 /** 80 * Creates a new Almanac_ReducedKeplerianSet from encoded stream. 81 */ 82 public static Almanac_ReducedKeplerianSet fromPerAligned(byte[] encodedBytes) { 83 Almanac_ReducedKeplerianSet result = new Almanac_ReducedKeplerianSet(); 84 result.decodePerAligned(new BitStreamReader(encodedBytes)); 85 return result; 86 } 87 88 89 90 @Override protected boolean isExtensible() { 91 return false; 92 } 93 94 @Override public boolean containsExtensionValues() { 95 for (SequenceComponent extensionComponent : getExtensionComponents()) { 96 if (extensionComponent.isExplicitlySet()) return true; 97 } 98 return false; 99 } 100 101 102 private SVID svID_; 103 public SVID getSvID() { 104 return svID_; 105 } 106 /** 107 * @throws ClassCastException if value is not a SVID 108 */ 109 public void setSvID(Asn1Object value) { 110 this.svID_ = (SVID) value; 111 } 112 public SVID setSvIDToNewInstance() { 113 svID_ = new SVID(); 114 return svID_; 115 } 116 117 private Almanac_ReducedKeplerianSet.redAlmDeltaAType redAlmDeltaA_; 118 public Almanac_ReducedKeplerianSet.redAlmDeltaAType getRedAlmDeltaA() { 119 return redAlmDeltaA_; 120 } 121 /** 122 * @throws ClassCastException if value is not a Almanac_ReducedKeplerianSet.redAlmDeltaAType 123 */ 124 public void setRedAlmDeltaA(Asn1Object value) { 125 this.redAlmDeltaA_ = (Almanac_ReducedKeplerianSet.redAlmDeltaAType) value; 126 } 127 public Almanac_ReducedKeplerianSet.redAlmDeltaAType setRedAlmDeltaAToNewInstance() { 128 redAlmDeltaA_ = new Almanac_ReducedKeplerianSet.redAlmDeltaAType(); 129 return redAlmDeltaA_; 130 } 131 132 private Almanac_ReducedKeplerianSet.redAlmOmega0Type redAlmOmega0_; 133 public Almanac_ReducedKeplerianSet.redAlmOmega0Type getRedAlmOmega0() { 134 return redAlmOmega0_; 135 } 136 /** 137 * @throws ClassCastException if value is not a Almanac_ReducedKeplerianSet.redAlmOmega0Type 138 */ 139 public void setRedAlmOmega0(Asn1Object value) { 140 this.redAlmOmega0_ = (Almanac_ReducedKeplerianSet.redAlmOmega0Type) value; 141 } 142 public Almanac_ReducedKeplerianSet.redAlmOmega0Type setRedAlmOmega0ToNewInstance() { 143 redAlmOmega0_ = new Almanac_ReducedKeplerianSet.redAlmOmega0Type(); 144 return redAlmOmega0_; 145 } 146 147 private Almanac_ReducedKeplerianSet.redAlmPhi0Type redAlmPhi0_; 148 public Almanac_ReducedKeplerianSet.redAlmPhi0Type getRedAlmPhi0() { 149 return redAlmPhi0_; 150 } 151 /** 152 * @throws ClassCastException if value is not a Almanac_ReducedKeplerianSet.redAlmPhi0Type 153 */ 154 public void setRedAlmPhi0(Asn1Object value) { 155 this.redAlmPhi0_ = (Almanac_ReducedKeplerianSet.redAlmPhi0Type) value; 156 } 157 public Almanac_ReducedKeplerianSet.redAlmPhi0Type setRedAlmPhi0ToNewInstance() { 158 redAlmPhi0_ = new Almanac_ReducedKeplerianSet.redAlmPhi0Type(); 159 return redAlmPhi0_; 160 } 161 162 private Almanac_ReducedKeplerianSet.redAlmL1HealthType redAlmL1Health_; 163 public Almanac_ReducedKeplerianSet.redAlmL1HealthType getRedAlmL1Health() { 164 return redAlmL1Health_; 165 } 166 /** 167 * @throws ClassCastException if value is not a Almanac_ReducedKeplerianSet.redAlmL1HealthType 168 */ 169 public void setRedAlmL1Health(Asn1Object value) { 170 this.redAlmL1Health_ = (Almanac_ReducedKeplerianSet.redAlmL1HealthType) value; 171 } 172 public Almanac_ReducedKeplerianSet.redAlmL1HealthType setRedAlmL1HealthToNewInstance() { 173 redAlmL1Health_ = new Almanac_ReducedKeplerianSet.redAlmL1HealthType(); 174 return redAlmL1Health_; 175 } 176 177 private Almanac_ReducedKeplerianSet.redAlmL2HealthType redAlmL2Health_; 178 public Almanac_ReducedKeplerianSet.redAlmL2HealthType getRedAlmL2Health() { 179 return redAlmL2Health_; 180 } 181 /** 182 * @throws ClassCastException if value is not a Almanac_ReducedKeplerianSet.redAlmL2HealthType 183 */ 184 public void setRedAlmL2Health(Asn1Object value) { 185 this.redAlmL2Health_ = (Almanac_ReducedKeplerianSet.redAlmL2HealthType) value; 186 } 187 public Almanac_ReducedKeplerianSet.redAlmL2HealthType setRedAlmL2HealthToNewInstance() { 188 redAlmL2Health_ = new Almanac_ReducedKeplerianSet.redAlmL2HealthType(); 189 return redAlmL2Health_; 190 } 191 192 private Almanac_ReducedKeplerianSet.redAlmL5HealthType redAlmL5Health_; 193 public Almanac_ReducedKeplerianSet.redAlmL5HealthType getRedAlmL5Health() { 194 return redAlmL5Health_; 195 } 196 /** 197 * @throws ClassCastException if value is not a Almanac_ReducedKeplerianSet.redAlmL5HealthType 198 */ 199 public void setRedAlmL5Health(Asn1Object value) { 200 this.redAlmL5Health_ = (Almanac_ReducedKeplerianSet.redAlmL5HealthType) value; 201 } 202 public Almanac_ReducedKeplerianSet.redAlmL5HealthType setRedAlmL5HealthToNewInstance() { 203 redAlmL5Health_ = new Almanac_ReducedKeplerianSet.redAlmL5HealthType(); 204 return redAlmL5Health_; 205 } 206 207 208 209 210 211 212 @Override public Iterable<? extends SequenceComponent> getComponents() { 213 ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder(); 214 215 builder.add(new SequenceComponent() { 216 Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0); 217 218 @Override public boolean isExplicitlySet() { 219 return getSvID() != null; 220 } 221 222 @Override public boolean hasDefaultValue() { 223 return false; 224 } 225 226 @Override public boolean isOptional() { 227 return false; 228 } 229 230 @Override public Asn1Object getComponentValue() { 231 return getSvID(); 232 } 233 234 @Override public void setToNewInstance() { 235 setSvIDToNewInstance(); 236 } 237 238 @Override public Collection<Asn1Tag> getPossibleFirstTags() { 239 return tag == null ? SVID.getPossibleFirstTags() : ImmutableList.of(tag); 240 } 241 242 @Override 243 public Asn1Tag getTag() { 244 return tag; 245 } 246 247 @Override 248 public boolean isImplicitTagging() { 249 return true; 250 } 251 252 @Override public String toIndentedString(String indent) { 253 return "svID : " 254 + getSvID().toIndentedString(indent); 255 } 256 }); 257 258 builder.add(new SequenceComponent() { 259 Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1); 260 261 @Override public boolean isExplicitlySet() { 262 return getRedAlmDeltaA() != null; 263 } 264 265 @Override public boolean hasDefaultValue() { 266 return false; 267 } 268 269 @Override public boolean isOptional() { 270 return false; 271 } 272 273 @Override public Asn1Object getComponentValue() { 274 return getRedAlmDeltaA(); 275 } 276 277 @Override public void setToNewInstance() { 278 setRedAlmDeltaAToNewInstance(); 279 } 280 281 @Override public Collection<Asn1Tag> getPossibleFirstTags() { 282 return tag == null ? Almanac_ReducedKeplerianSet.redAlmDeltaAType.getPossibleFirstTags() : ImmutableList.of(tag); 283 } 284 285 @Override 286 public Asn1Tag getTag() { 287 return tag; 288 } 289 290 @Override 291 public boolean isImplicitTagging() { 292 return true; 293 } 294 295 @Override public String toIndentedString(String indent) { 296 return "redAlmDeltaA : " 297 + getRedAlmDeltaA().toIndentedString(indent); 298 } 299 }); 300 301 builder.add(new SequenceComponent() { 302 Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2); 303 304 @Override public boolean isExplicitlySet() { 305 return getRedAlmOmega0() != null; 306 } 307 308 @Override public boolean hasDefaultValue() { 309 return false; 310 } 311 312 @Override public boolean isOptional() { 313 return false; 314 } 315 316 @Override public Asn1Object getComponentValue() { 317 return getRedAlmOmega0(); 318 } 319 320 @Override public void setToNewInstance() { 321 setRedAlmOmega0ToNewInstance(); 322 } 323 324 @Override public Collection<Asn1Tag> getPossibleFirstTags() { 325 return tag == null ? Almanac_ReducedKeplerianSet.redAlmOmega0Type.getPossibleFirstTags() : ImmutableList.of(tag); 326 } 327 328 @Override 329 public Asn1Tag getTag() { 330 return tag; 331 } 332 333 @Override 334 public boolean isImplicitTagging() { 335 return true; 336 } 337 338 @Override public String toIndentedString(String indent) { 339 return "redAlmOmega0 : " 340 + getRedAlmOmega0().toIndentedString(indent); 341 } 342 }); 343 344 builder.add(new SequenceComponent() { 345 Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3); 346 347 @Override public boolean isExplicitlySet() { 348 return getRedAlmPhi0() != null; 349 } 350 351 @Override public boolean hasDefaultValue() { 352 return false; 353 } 354 355 @Override public boolean isOptional() { 356 return false; 357 } 358 359 @Override public Asn1Object getComponentValue() { 360 return getRedAlmPhi0(); 361 } 362 363 @Override public void setToNewInstance() { 364 setRedAlmPhi0ToNewInstance(); 365 } 366 367 @Override public Collection<Asn1Tag> getPossibleFirstTags() { 368 return tag == null ? Almanac_ReducedKeplerianSet.redAlmPhi0Type.getPossibleFirstTags() : ImmutableList.of(tag); 369 } 370 371 @Override 372 public Asn1Tag getTag() { 373 return tag; 374 } 375 376 @Override 377 public boolean isImplicitTagging() { 378 return true; 379 } 380 381 @Override public String toIndentedString(String indent) { 382 return "redAlmPhi0 : " 383 + getRedAlmPhi0().toIndentedString(indent); 384 } 385 }); 386 387 builder.add(new SequenceComponent() { 388 Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4); 389 390 @Override public boolean isExplicitlySet() { 391 return getRedAlmL1Health() != null; 392 } 393 394 @Override public boolean hasDefaultValue() { 395 return false; 396 } 397 398 @Override public boolean isOptional() { 399 return false; 400 } 401 402 @Override public Asn1Object getComponentValue() { 403 return getRedAlmL1Health(); 404 } 405 406 @Override public void setToNewInstance() { 407 setRedAlmL1HealthToNewInstance(); 408 } 409 410 @Override public Collection<Asn1Tag> getPossibleFirstTags() { 411 return tag == null ? Almanac_ReducedKeplerianSet.redAlmL1HealthType.getPossibleFirstTags() : ImmutableList.of(tag); 412 } 413 414 @Override 415 public Asn1Tag getTag() { 416 return tag; 417 } 418 419 @Override 420 public boolean isImplicitTagging() { 421 return true; 422 } 423 424 @Override public String toIndentedString(String indent) { 425 return "redAlmL1Health : " 426 + getRedAlmL1Health().toIndentedString(indent); 427 } 428 }); 429 430 builder.add(new SequenceComponent() { 431 Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 5); 432 433 @Override public boolean isExplicitlySet() { 434 return getRedAlmL2Health() != null; 435 } 436 437 @Override public boolean hasDefaultValue() { 438 return false; 439 } 440 441 @Override public boolean isOptional() { 442 return false; 443 } 444 445 @Override public Asn1Object getComponentValue() { 446 return getRedAlmL2Health(); 447 } 448 449 @Override public void setToNewInstance() { 450 setRedAlmL2HealthToNewInstance(); 451 } 452 453 @Override public Collection<Asn1Tag> getPossibleFirstTags() { 454 return tag == null ? Almanac_ReducedKeplerianSet.redAlmL2HealthType.getPossibleFirstTags() : ImmutableList.of(tag); 455 } 456 457 @Override 458 public Asn1Tag getTag() { 459 return tag; 460 } 461 462 @Override 463 public boolean isImplicitTagging() { 464 return true; 465 } 466 467 @Override public String toIndentedString(String indent) { 468 return "redAlmL2Health : " 469 + getRedAlmL2Health().toIndentedString(indent); 470 } 471 }); 472 473 builder.add(new SequenceComponent() { 474 Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 6); 475 476 @Override public boolean isExplicitlySet() { 477 return getRedAlmL5Health() != null; 478 } 479 480 @Override public boolean hasDefaultValue() { 481 return false; 482 } 483 484 @Override public boolean isOptional() { 485 return false; 486 } 487 488 @Override public Asn1Object getComponentValue() { 489 return getRedAlmL5Health(); 490 } 491 492 @Override public void setToNewInstance() { 493 setRedAlmL5HealthToNewInstance(); 494 } 495 496 @Override public Collection<Asn1Tag> getPossibleFirstTags() { 497 return tag == null ? Almanac_ReducedKeplerianSet.redAlmL5HealthType.getPossibleFirstTags() : ImmutableList.of(tag); 498 } 499 500 @Override 501 public Asn1Tag getTag() { 502 return tag; 503 } 504 505 @Override 506 public boolean isImplicitTagging() { 507 return true; 508 } 509 510 @Override public String toIndentedString(String indent) { 511 return "redAlmL5Health : " 512 + getRedAlmL5Health().toIndentedString(indent); 513 } 514 }); 515 516 return builder.build(); 517 } 518 519 @Override public Iterable<? extends SequenceComponent> 520 getExtensionComponents() { 521 ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder(); 522 523 return builder.build(); 524 } 525 526 527 528 529 /* 530 */ 531 532 533 // 534 535 /** 536 */ 537 public static class redAlmDeltaAType extends Asn1Integer { 538 // 539 540 private static final Asn1Tag TAG_redAlmDeltaAType 541 = Asn1Tag.fromClassAndNumber(-1, -1); 542 543 public redAlmDeltaAType() { 544 super(); 545 setValueRange("-128", "127"); 546 547 } 548 549 @Override 550 @Nullable 551 protected Asn1Tag getTag() { 552 return TAG_redAlmDeltaAType; 553 } 554 555 @Override 556 protected boolean isTagImplicit() { 557 return true; 558 } 559 560 public static Collection<Asn1Tag> getPossibleFirstTags() { 561 if (TAG_redAlmDeltaAType != null) { 562 return ImmutableList.of(TAG_redAlmDeltaAType); 563 } else { 564 return Asn1Integer.getPossibleFirstTags(); 565 } 566 } 567 568 /** 569 * Creates a new redAlmDeltaAType from encoded stream. 570 */ 571 public static redAlmDeltaAType fromPerUnaligned(byte[] encodedBytes) { 572 redAlmDeltaAType result = new redAlmDeltaAType(); 573 result.decodePerUnaligned(new BitStreamReader(encodedBytes)); 574 return result; 575 } 576 577 /** 578 * Creates a new redAlmDeltaAType from encoded stream. 579 */ 580 public static redAlmDeltaAType fromPerAligned(byte[] encodedBytes) { 581 redAlmDeltaAType result = new redAlmDeltaAType(); 582 result.decodePerAligned(new BitStreamReader(encodedBytes)); 583 return result; 584 } 585 586 @Override public Iterable<BitStream> encodePerUnaligned() { 587 return super.encodePerUnaligned(); 588 } 589 590 @Override public Iterable<BitStream> encodePerAligned() { 591 return super.encodePerAligned(); 592 } 593 594 @Override public void decodePerUnaligned(BitStreamReader reader) { 595 super.decodePerUnaligned(reader); 596 } 597 598 @Override public void decodePerAligned(BitStreamReader reader) { 599 super.decodePerAligned(reader); 600 } 601 602 @Override public String toString() { 603 return toIndentedString(""); 604 } 605 606 public String toIndentedString(String indent) { 607 return "redAlmDeltaAType = " + getInteger() + ";\n"; 608 } 609 } 610 611 612 /* 613 */ 614 615 616 // 617 618 /** 619 */ 620 public static class redAlmOmega0Type extends Asn1Integer { 621 // 622 623 private static final Asn1Tag TAG_redAlmOmega0Type 624 = Asn1Tag.fromClassAndNumber(-1, -1); 625 626 public redAlmOmega0Type() { 627 super(); 628 setValueRange("-64", "63"); 629 630 } 631 632 @Override 633 @Nullable 634 protected Asn1Tag getTag() { 635 return TAG_redAlmOmega0Type; 636 } 637 638 @Override 639 protected boolean isTagImplicit() { 640 return true; 641 } 642 643 public static Collection<Asn1Tag> getPossibleFirstTags() { 644 if (TAG_redAlmOmega0Type != null) { 645 return ImmutableList.of(TAG_redAlmOmega0Type); 646 } else { 647 return Asn1Integer.getPossibleFirstTags(); 648 } 649 } 650 651 /** 652 * Creates a new redAlmOmega0Type from encoded stream. 653 */ 654 public static redAlmOmega0Type fromPerUnaligned(byte[] encodedBytes) { 655 redAlmOmega0Type result = new redAlmOmega0Type(); 656 result.decodePerUnaligned(new BitStreamReader(encodedBytes)); 657 return result; 658 } 659 660 /** 661 * Creates a new redAlmOmega0Type from encoded stream. 662 */ 663 public static redAlmOmega0Type fromPerAligned(byte[] encodedBytes) { 664 redAlmOmega0Type result = new redAlmOmega0Type(); 665 result.decodePerAligned(new BitStreamReader(encodedBytes)); 666 return result; 667 } 668 669 @Override public Iterable<BitStream> encodePerUnaligned() { 670 return super.encodePerUnaligned(); 671 } 672 673 @Override public Iterable<BitStream> encodePerAligned() { 674 return super.encodePerAligned(); 675 } 676 677 @Override public void decodePerUnaligned(BitStreamReader reader) { 678 super.decodePerUnaligned(reader); 679 } 680 681 @Override public void decodePerAligned(BitStreamReader reader) { 682 super.decodePerAligned(reader); 683 } 684 685 @Override public String toString() { 686 return toIndentedString(""); 687 } 688 689 public String toIndentedString(String indent) { 690 return "redAlmOmega0Type = " + getInteger() + ";\n"; 691 } 692 } 693 694 695 /* 696 */ 697 698 699 // 700 701 /** 702 */ 703 public static class redAlmPhi0Type extends Asn1Integer { 704 // 705 706 private static final Asn1Tag TAG_redAlmPhi0Type 707 = Asn1Tag.fromClassAndNumber(-1, -1); 708 709 public redAlmPhi0Type() { 710 super(); 711 setValueRange("-64", "63"); 712 713 } 714 715 @Override 716 @Nullable 717 protected Asn1Tag getTag() { 718 return TAG_redAlmPhi0Type; 719 } 720 721 @Override 722 protected boolean isTagImplicit() { 723 return true; 724 } 725 726 public static Collection<Asn1Tag> getPossibleFirstTags() { 727 if (TAG_redAlmPhi0Type != null) { 728 return ImmutableList.of(TAG_redAlmPhi0Type); 729 } else { 730 return Asn1Integer.getPossibleFirstTags(); 731 } 732 } 733 734 /** 735 * Creates a new redAlmPhi0Type from encoded stream. 736 */ 737 public static redAlmPhi0Type fromPerUnaligned(byte[] encodedBytes) { 738 redAlmPhi0Type result = new redAlmPhi0Type(); 739 result.decodePerUnaligned(new BitStreamReader(encodedBytes)); 740 return result; 741 } 742 743 /** 744 * Creates a new redAlmPhi0Type from encoded stream. 745 */ 746 public static redAlmPhi0Type fromPerAligned(byte[] encodedBytes) { 747 redAlmPhi0Type result = new redAlmPhi0Type(); 748 result.decodePerAligned(new BitStreamReader(encodedBytes)); 749 return result; 750 } 751 752 @Override public Iterable<BitStream> encodePerUnaligned() { 753 return super.encodePerUnaligned(); 754 } 755 756 @Override public Iterable<BitStream> encodePerAligned() { 757 return super.encodePerAligned(); 758 } 759 760 @Override public void decodePerUnaligned(BitStreamReader reader) { 761 super.decodePerUnaligned(reader); 762 } 763 764 @Override public void decodePerAligned(BitStreamReader reader) { 765 super.decodePerAligned(reader); 766 } 767 768 @Override public String toString() { 769 return toIndentedString(""); 770 } 771 772 public String toIndentedString(String indent) { 773 return "redAlmPhi0Type = " + getInteger() + ";\n"; 774 } 775 } 776 777 778 /* 779 */ 780 781 782 // 783 784 /** 785 */ 786 public static class redAlmL1HealthType extends Asn1Boolean { 787 // 788 789 private static final Asn1Tag TAG_redAlmL1HealthType 790 = Asn1Tag.fromClassAndNumber(-1, -1); 791 792 public redAlmL1HealthType() { 793 super(); 794 } 795 796 @Override 797 @Nullable 798 protected Asn1Tag getTag() { 799 return TAG_redAlmL1HealthType; 800 } 801 802 @Override 803 protected boolean isTagImplicit() { 804 return true; 805 } 806 807 public static Collection<Asn1Tag> getPossibleFirstTags() { 808 if (TAG_redAlmL1HealthType != null) { 809 return ImmutableList.of(TAG_redAlmL1HealthType); 810 } else { 811 return Asn1Boolean.getPossibleFirstTags(); 812 } 813 } 814 815 /** 816 * Creates a new redAlmL1HealthType from encoded stream. 817 */ 818 public static redAlmL1HealthType fromPerUnaligned(byte[] encodedBytes) { 819 redAlmL1HealthType result = new redAlmL1HealthType(); 820 result.decodePerUnaligned(new BitStreamReader(encodedBytes)); 821 return result; 822 } 823 824 /** 825 * Creates a new redAlmL1HealthType from encoded stream. 826 */ 827 public static redAlmL1HealthType fromPerAligned(byte[] encodedBytes) { 828 redAlmL1HealthType result = new redAlmL1HealthType(); 829 result.decodePerAligned(new BitStreamReader(encodedBytes)); 830 return result; 831 } 832 833 @Override public Iterable<BitStream> encodePerUnaligned() { 834 return super.encodePerUnaligned(); 835 } 836 837 @Override public Iterable<BitStream> encodePerAligned() { 838 return super.encodePerAligned(); 839 } 840 841 @Override public void decodePerUnaligned(BitStreamReader reader) { 842 super.decodePerUnaligned(reader); 843 } 844 845 @Override public void decodePerAligned(BitStreamReader reader) { 846 super.decodePerAligned(reader); 847 } 848 849 @Override public String toString() { 850 return toIndentedString(""); 851 } 852 853 public String toIndentedString(String indent) { 854 return "redAlmL1HealthType = " + getValue() + ";\n"; 855 } 856 } 857 858 859 /* 860 */ 861 862 863 // 864 865 /** 866 */ 867 public static class redAlmL2HealthType extends Asn1Boolean { 868 // 869 870 private static final Asn1Tag TAG_redAlmL2HealthType 871 = Asn1Tag.fromClassAndNumber(-1, -1); 872 873 public redAlmL2HealthType() { 874 super(); 875 } 876 877 @Override 878 @Nullable 879 protected Asn1Tag getTag() { 880 return TAG_redAlmL2HealthType; 881 } 882 883 @Override 884 protected boolean isTagImplicit() { 885 return true; 886 } 887 888 public static Collection<Asn1Tag> getPossibleFirstTags() { 889 if (TAG_redAlmL2HealthType != null) { 890 return ImmutableList.of(TAG_redAlmL2HealthType); 891 } else { 892 return Asn1Boolean.getPossibleFirstTags(); 893 } 894 } 895 896 /** 897 * Creates a new redAlmL2HealthType from encoded stream. 898 */ 899 public static redAlmL2HealthType fromPerUnaligned(byte[] encodedBytes) { 900 redAlmL2HealthType result = new redAlmL2HealthType(); 901 result.decodePerUnaligned(new BitStreamReader(encodedBytes)); 902 return result; 903 } 904 905 /** 906 * Creates a new redAlmL2HealthType from encoded stream. 907 */ 908 public static redAlmL2HealthType fromPerAligned(byte[] encodedBytes) { 909 redAlmL2HealthType result = new redAlmL2HealthType(); 910 result.decodePerAligned(new BitStreamReader(encodedBytes)); 911 return result; 912 } 913 914 @Override public Iterable<BitStream> encodePerUnaligned() { 915 return super.encodePerUnaligned(); 916 } 917 918 @Override public Iterable<BitStream> encodePerAligned() { 919 return super.encodePerAligned(); 920 } 921 922 @Override public void decodePerUnaligned(BitStreamReader reader) { 923 super.decodePerUnaligned(reader); 924 } 925 926 @Override public void decodePerAligned(BitStreamReader reader) { 927 super.decodePerAligned(reader); 928 } 929 930 @Override public String toString() { 931 return toIndentedString(""); 932 } 933 934 public String toIndentedString(String indent) { 935 return "redAlmL2HealthType = " + getValue() + ";\n"; 936 } 937 } 938 939 940 /* 941 */ 942 943 944 // 945 946 /** 947 */ 948 public static class redAlmL5HealthType extends Asn1Boolean { 949 // 950 951 private static final Asn1Tag TAG_redAlmL5HealthType 952 = Asn1Tag.fromClassAndNumber(-1, -1); 953 954 public redAlmL5HealthType() { 955 super(); 956 } 957 958 @Override 959 @Nullable 960 protected Asn1Tag getTag() { 961 return TAG_redAlmL5HealthType; 962 } 963 964 @Override 965 protected boolean isTagImplicit() { 966 return true; 967 } 968 969 public static Collection<Asn1Tag> getPossibleFirstTags() { 970 if (TAG_redAlmL5HealthType != null) { 971 return ImmutableList.of(TAG_redAlmL5HealthType); 972 } else { 973 return Asn1Boolean.getPossibleFirstTags(); 974 } 975 } 976 977 /** 978 * Creates a new redAlmL5HealthType from encoded stream. 979 */ 980 public static redAlmL5HealthType fromPerUnaligned(byte[] encodedBytes) { 981 redAlmL5HealthType result = new redAlmL5HealthType(); 982 result.decodePerUnaligned(new BitStreamReader(encodedBytes)); 983 return result; 984 } 985 986 /** 987 * Creates a new redAlmL5HealthType from encoded stream. 988 */ 989 public static redAlmL5HealthType fromPerAligned(byte[] encodedBytes) { 990 redAlmL5HealthType result = new redAlmL5HealthType(); 991 result.decodePerAligned(new BitStreamReader(encodedBytes)); 992 return result; 993 } 994 995 @Override public Iterable<BitStream> encodePerUnaligned() { 996 return super.encodePerUnaligned(); 997 } 998 999 @Override public Iterable<BitStream> encodePerAligned() { 1000 return super.encodePerAligned(); 1001 } 1002 1003 @Override public void decodePerUnaligned(BitStreamReader reader) { 1004 super.decodePerUnaligned(reader); 1005 } 1006 1007 @Override public void decodePerAligned(BitStreamReader reader) { 1008 super.decodePerAligned(reader); 1009 } 1010 1011 @Override public String toString() { 1012 return toIndentedString(""); 1013 } 1014 1015 public String toIndentedString(String indent) { 1016 return "redAlmL5HealthType = " + getValue() + ";\n"; 1017 } 1018 } 1019 1020 1021 1022 1023 1024 @Override public Iterable<BitStream> encodePerUnaligned() { 1025 return super.encodePerUnaligned(); 1026 } 1027 1028 @Override public Iterable<BitStream> encodePerAligned() { 1029 return super.encodePerAligned(); 1030 } 1031 1032 @Override public void decodePerUnaligned(BitStreamReader reader) { 1033 super.decodePerUnaligned(reader); 1034 } 1035 1036 @Override public void decodePerAligned(BitStreamReader reader) { 1037 super.decodePerAligned(reader); 1038 } 1039 1040 @Override public String toString() { 1041 return toIndentedString(""); 1042 } 1043 1044 public String toIndentedString(String indent) { 1045 StringBuilder builder = new StringBuilder(); 1046 builder.append("Almanac_ReducedKeplerianSet = {\n"); 1047 final String internalIndent = indent + " "; 1048 for (SequenceComponent component : getComponents()) { 1049 if (component.isExplicitlySet()) { 1050 builder.append(internalIndent) 1051 .append(component.toIndentedString(internalIndent)); 1052 } 1053 } 1054 if (isExtensible()) { 1055 builder.append(internalIndent).append("...\n"); 1056 for (SequenceComponent component : getExtensionComponents()) { 1057 if (component.isExplicitlySet()) { 1058 builder.append(internalIndent) 1059 .append(component.toIndentedString(internalIndent)); 1060 } 1061 } 1062 } 1063 builder.append(indent).append("};\n"); 1064 return builder.toString(); 1065 } 1066 } 1067
