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