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.ver2_ulp_components; 18 19 /* 20 */ 21 22 23 // 24 // 25 import android.location.cts.asn1.base.Asn1Choice; 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.ChoiceComponent; 34 import android.location.cts.asn1.base.SequenceComponent; 35 import android.location.cts.asn1.supl2.ulp_components.CellParametersID; 36 import android.location.cts.asn1.supl2.ulp_components.PrimaryCPICH_Info; 37 import com.google.common.collect.ImmutableList; 38 import java.nio.ByteBuffer; 39 import java.util.Collection; 40 import java.util.HashMap; 41 import java.util.Map; 42 import javax.annotation.Nullable; 43 44 45 /** 46 */ 47 public class UTRAN_GANSSReferenceTime extends Asn1Sequence { 48 // 49 50 private static final Asn1Tag TAG_UTRAN_GANSSReferenceTime 51 = Asn1Tag.fromClassAndNumber(-1, -1); 52 53 public UTRAN_GANSSReferenceTime() { 54 super(); 55 } 56 57 @Override 58 @Nullable 59 protected Asn1Tag getTag() { 60 return TAG_UTRAN_GANSSReferenceTime; 61 } 62 63 @Override 64 protected boolean isTagImplicit() { 65 return true; 66 } 67 68 public static Collection<Asn1Tag> getPossibleFirstTags() { 69 if (TAG_UTRAN_GANSSReferenceTime != null) { 70 return ImmutableList.of(TAG_UTRAN_GANSSReferenceTime); 71 } else { 72 return Asn1Sequence.getPossibleFirstTags(); 73 } 74 } 75 76 /** 77 * Creates a new UTRAN_GANSSReferenceTime from encoded stream. 78 */ 79 public static UTRAN_GANSSReferenceTime fromPerUnaligned(byte[] encodedBytes) { 80 UTRAN_GANSSReferenceTime result = new UTRAN_GANSSReferenceTime(); 81 result.decodePerUnaligned(new BitStreamReader(encodedBytes)); 82 return result; 83 } 84 85 /** 86 * Creates a new UTRAN_GANSSReferenceTime from encoded stream. 87 */ 88 public static UTRAN_GANSSReferenceTime fromPerAligned(byte[] encodedBytes) { 89 UTRAN_GANSSReferenceTime result = new UTRAN_GANSSReferenceTime(); 90 result.decodePerAligned(new BitStreamReader(encodedBytes)); 91 return result; 92 } 93 94 95 96 @Override protected boolean isExtensible() { 97 return true; 98 } 99 100 @Override public boolean containsExtensionValues() { 101 for (SequenceComponent extensionComponent : getExtensionComponents()) { 102 if (extensionComponent.isExplicitlySet()) return true; 103 } 104 return false; 105 } 106 107 108 private UTRAN_GANSSReferenceTime.ganssTODType ganssTOD_; 109 public UTRAN_GANSSReferenceTime.ganssTODType getGanssTOD() { 110 return ganssTOD_; 111 } 112 /** 113 * @throws ClassCastException if value is not a UTRAN_GANSSReferenceTime.ganssTODType 114 */ 115 public void setGanssTOD(Asn1Object value) { 116 this.ganssTOD_ = (UTRAN_GANSSReferenceTime.ganssTODType) value; 117 } 118 public UTRAN_GANSSReferenceTime.ganssTODType setGanssTODToNewInstance() { 119 ganssTOD_ = new UTRAN_GANSSReferenceTime.ganssTODType(); 120 return ganssTOD_; 121 } 122 123 private UTRAN_GANSSReferenceTime.utran_GANSSTimingOfCellType utran_GANSSTimingOfCell_; 124 public UTRAN_GANSSReferenceTime.utran_GANSSTimingOfCellType getUtran_GANSSTimingOfCell() { 125 return utran_GANSSTimingOfCell_; 126 } 127 /** 128 * @throws ClassCastException if value is not a UTRAN_GANSSReferenceTime.utran_GANSSTimingOfCellType 129 */ 130 public void setUtran_GANSSTimingOfCell(Asn1Object value) { 131 this.utran_GANSSTimingOfCell_ = (UTRAN_GANSSReferenceTime.utran_GANSSTimingOfCellType) value; 132 } 133 public UTRAN_GANSSReferenceTime.utran_GANSSTimingOfCellType setUtran_GANSSTimingOfCellToNewInstance() { 134 utran_GANSSTimingOfCell_ = new UTRAN_GANSSReferenceTime.utran_GANSSTimingOfCellType(); 135 return utran_GANSSTimingOfCell_; 136 } 137 138 private UTRAN_GANSSReferenceTime.modeSpecificInfoType modeSpecificInfo_; 139 public UTRAN_GANSSReferenceTime.modeSpecificInfoType getModeSpecificInfo() { 140 return modeSpecificInfo_; 141 } 142 /** 143 * @throws ClassCastException if value is not a UTRAN_GANSSReferenceTime.modeSpecificInfoType 144 */ 145 public void setModeSpecificInfo(Asn1Object value) { 146 this.modeSpecificInfo_ = (UTRAN_GANSSReferenceTime.modeSpecificInfoType) value; 147 } 148 public UTRAN_GANSSReferenceTime.modeSpecificInfoType setModeSpecificInfoToNewInstance() { 149 modeSpecificInfo_ = new UTRAN_GANSSReferenceTime.modeSpecificInfoType(); 150 return modeSpecificInfo_; 151 } 152 153 private UTRAN_GANSSReferenceTime.sfnType sfn_; 154 public UTRAN_GANSSReferenceTime.sfnType getSfn() { 155 return sfn_; 156 } 157 /** 158 * @throws ClassCastException if value is not a UTRAN_GANSSReferenceTime.sfnType 159 */ 160 public void setSfn(Asn1Object value) { 161 this.sfn_ = (UTRAN_GANSSReferenceTime.sfnType) value; 162 } 163 public UTRAN_GANSSReferenceTime.sfnType setSfnToNewInstance() { 164 sfn_ = new UTRAN_GANSSReferenceTime.sfnType(); 165 return sfn_; 166 } 167 168 private UTRAN_GANSSReferenceTime.ganss_TODUncertaintyType ganss_TODUncertainty_; 169 public UTRAN_GANSSReferenceTime.ganss_TODUncertaintyType getGanss_TODUncertainty() { 170 return ganss_TODUncertainty_; 171 } 172 /** 173 * @throws ClassCastException if value is not a UTRAN_GANSSReferenceTime.ganss_TODUncertaintyType 174 */ 175 public void setGanss_TODUncertainty(Asn1Object value) { 176 this.ganss_TODUncertainty_ = (UTRAN_GANSSReferenceTime.ganss_TODUncertaintyType) value; 177 } 178 public UTRAN_GANSSReferenceTime.ganss_TODUncertaintyType setGanss_TODUncertaintyToNewInstance() { 179 ganss_TODUncertainty_ = new UTRAN_GANSSReferenceTime.ganss_TODUncertaintyType(); 180 return ganss_TODUncertainty_; 181 } 182 183 184 185 186 187 188 @Override public Iterable<? extends SequenceComponent> getComponents() { 189 ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder(); 190 191 builder.add(new SequenceComponent() { 192 Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0); 193 194 @Override public boolean isExplicitlySet() { 195 return getGanssTOD() != null; 196 } 197 198 @Override public boolean hasDefaultValue() { 199 return false; 200 } 201 202 @Override public boolean isOptional() { 203 return false; 204 } 205 206 @Override public Asn1Object getComponentValue() { 207 return getGanssTOD(); 208 } 209 210 @Override public void setToNewInstance() { 211 setGanssTODToNewInstance(); 212 } 213 214 @Override public Collection<Asn1Tag> getPossibleFirstTags() { 215 return tag == null ? UTRAN_GANSSReferenceTime.ganssTODType.getPossibleFirstTags() : ImmutableList.of(tag); 216 } 217 218 @Override 219 public Asn1Tag getTag() { 220 return tag; 221 } 222 223 @Override 224 public boolean isImplicitTagging() { 225 return true; 226 } 227 228 @Override public String toIndentedString(String indent) { 229 return "ganssTOD : " 230 + getGanssTOD().toIndentedString(indent); 231 } 232 }); 233 234 builder.add(new SequenceComponent() { 235 Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1); 236 237 @Override public boolean isExplicitlySet() { 238 return getUtran_GANSSTimingOfCell() != null; 239 } 240 241 @Override public boolean hasDefaultValue() { 242 return false; 243 } 244 245 @Override public boolean isOptional() { 246 return true; 247 } 248 249 @Override public Asn1Object getComponentValue() { 250 return getUtran_GANSSTimingOfCell(); 251 } 252 253 @Override public void setToNewInstance() { 254 setUtran_GANSSTimingOfCellToNewInstance(); 255 } 256 257 @Override public Collection<Asn1Tag> getPossibleFirstTags() { 258 return tag == null ? UTRAN_GANSSReferenceTime.utran_GANSSTimingOfCellType.getPossibleFirstTags() : ImmutableList.of(tag); 259 } 260 261 @Override 262 public Asn1Tag getTag() { 263 return tag; 264 } 265 266 @Override 267 public boolean isImplicitTagging() { 268 return true; 269 } 270 271 @Override public String toIndentedString(String indent) { 272 return "utran_GANSSTimingOfCell : " 273 + getUtran_GANSSTimingOfCell().toIndentedString(indent); 274 } 275 }); 276 277 builder.add(new SequenceComponent() { 278 Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2); 279 280 @Override public boolean isExplicitlySet() { 281 return getModeSpecificInfo() != null; 282 } 283 284 @Override public boolean hasDefaultValue() { 285 return false; 286 } 287 288 @Override public boolean isOptional() { 289 return true; 290 } 291 292 @Override public Asn1Object getComponentValue() { 293 return getModeSpecificInfo(); 294 } 295 296 @Override public void setToNewInstance() { 297 setModeSpecificInfoToNewInstance(); 298 } 299 300 @Override public Collection<Asn1Tag> getPossibleFirstTags() { 301 return tag == null ? UTRAN_GANSSReferenceTime.modeSpecificInfoType.getPossibleFirstTags() : ImmutableList.of(tag); 302 } 303 304 @Override 305 public Asn1Tag getTag() { 306 return tag; 307 } 308 309 @Override 310 public boolean isImplicitTagging() { 311 return true; 312 } 313 314 @Override public String toIndentedString(String indent) { 315 return "modeSpecificInfo : " 316 + getModeSpecificInfo().toIndentedString(indent); 317 } 318 }); 319 320 builder.add(new SequenceComponent() { 321 Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3); 322 323 @Override public boolean isExplicitlySet() { 324 return getSfn() != null; 325 } 326 327 @Override public boolean hasDefaultValue() { 328 return false; 329 } 330 331 @Override public boolean isOptional() { 332 return false; 333 } 334 335 @Override public Asn1Object getComponentValue() { 336 return getSfn(); 337 } 338 339 @Override public void setToNewInstance() { 340 setSfnToNewInstance(); 341 } 342 343 @Override public Collection<Asn1Tag> getPossibleFirstTags() { 344 return tag == null ? UTRAN_GANSSReferenceTime.sfnType.getPossibleFirstTags() : ImmutableList.of(tag); 345 } 346 347 @Override 348 public Asn1Tag getTag() { 349 return tag; 350 } 351 352 @Override 353 public boolean isImplicitTagging() { 354 return true; 355 } 356 357 @Override public String toIndentedString(String indent) { 358 return "sfn : " 359 + getSfn().toIndentedString(indent); 360 } 361 }); 362 363 builder.add(new SequenceComponent() { 364 Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4); 365 366 @Override public boolean isExplicitlySet() { 367 return getGanss_TODUncertainty() != null; 368 } 369 370 @Override public boolean hasDefaultValue() { 371 return false; 372 } 373 374 @Override public boolean isOptional() { 375 return true; 376 } 377 378 @Override public Asn1Object getComponentValue() { 379 return getGanss_TODUncertainty(); 380 } 381 382 @Override public void setToNewInstance() { 383 setGanss_TODUncertaintyToNewInstance(); 384 } 385 386 @Override public Collection<Asn1Tag> getPossibleFirstTags() { 387 return tag == null ? UTRAN_GANSSReferenceTime.ganss_TODUncertaintyType.getPossibleFirstTags() : ImmutableList.of(tag); 388 } 389 390 @Override 391 public Asn1Tag getTag() { 392 return tag; 393 } 394 395 @Override 396 public boolean isImplicitTagging() { 397 return true; 398 } 399 400 @Override public String toIndentedString(String indent) { 401 return "ganss_TODUncertainty : " 402 + getGanss_TODUncertainty().toIndentedString(indent); 403 } 404 }); 405 406 return builder.build(); 407 } 408 409 @Override public Iterable<? extends SequenceComponent> 410 getExtensionComponents() { 411 ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder(); 412 413 return builder.build(); 414 } 415 416 417 /* 418 */ 419 420 421 // 422 423 /** 424 */ 425 public static class ganssTODType extends Asn1Integer { 426 // 427 428 private static final Asn1Tag TAG_ganssTODType 429 = Asn1Tag.fromClassAndNumber(-1, -1); 430 431 public ganssTODType() { 432 super(); 433 setValueRange("0", "86399"); 434 435 } 436 437 @Override 438 @Nullable 439 protected Asn1Tag getTag() { 440 return TAG_ganssTODType; 441 } 442 443 @Override 444 protected boolean isTagImplicit() { 445 return true; 446 } 447 448 public static Collection<Asn1Tag> getPossibleFirstTags() { 449 if (TAG_ganssTODType != null) { 450 return ImmutableList.of(TAG_ganssTODType); 451 } else { 452 return Asn1Integer.getPossibleFirstTags(); 453 } 454 } 455 456 /** 457 * Creates a new ganssTODType from encoded stream. 458 */ 459 public static ganssTODType fromPerUnaligned(byte[] encodedBytes) { 460 ganssTODType result = new ganssTODType(); 461 result.decodePerUnaligned(new BitStreamReader(encodedBytes)); 462 return result; 463 } 464 465 /** 466 * Creates a new ganssTODType from encoded stream. 467 */ 468 public static ganssTODType fromPerAligned(byte[] encodedBytes) { 469 ganssTODType result = new ganssTODType(); 470 result.decodePerAligned(new BitStreamReader(encodedBytes)); 471 return result; 472 } 473 474 @Override public Iterable<BitStream> encodePerUnaligned() { 475 return super.encodePerUnaligned(); 476 } 477 478 @Override public Iterable<BitStream> encodePerAligned() { 479 return super.encodePerAligned(); 480 } 481 482 @Override public void decodePerUnaligned(BitStreamReader reader) { 483 super.decodePerUnaligned(reader); 484 } 485 486 @Override public void decodePerAligned(BitStreamReader reader) { 487 super.decodePerAligned(reader); 488 } 489 490 @Override public String toString() { 491 return toIndentedString(""); 492 } 493 494 public String toIndentedString(String indent) { 495 return "ganssTODType = " + getInteger() + ";\n"; 496 } 497 } 498 499 500 /* 501 */ 502 503 504 // 505 506 /** 507 */ 508 public static class utran_GANSSTimingOfCellType extends Asn1Integer { 509 // 510 511 private static final Asn1Tag TAG_utran_GANSSTimingOfCellType 512 = Asn1Tag.fromClassAndNumber(-1, -1); 513 514 public utran_GANSSTimingOfCellType() { 515 super(); 516 setValueRange("0", "3999999"); 517 518 } 519 520 @Override 521 @Nullable 522 protected Asn1Tag getTag() { 523 return TAG_utran_GANSSTimingOfCellType; 524 } 525 526 @Override 527 protected boolean isTagImplicit() { 528 return true; 529 } 530 531 public static Collection<Asn1Tag> getPossibleFirstTags() { 532 if (TAG_utran_GANSSTimingOfCellType != null) { 533 return ImmutableList.of(TAG_utran_GANSSTimingOfCellType); 534 } else { 535 return Asn1Integer.getPossibleFirstTags(); 536 } 537 } 538 539 /** 540 * Creates a new utran_GANSSTimingOfCellType from encoded stream. 541 */ 542 public static utran_GANSSTimingOfCellType fromPerUnaligned(byte[] encodedBytes) { 543 utran_GANSSTimingOfCellType result = new utran_GANSSTimingOfCellType(); 544 result.decodePerUnaligned(new BitStreamReader(encodedBytes)); 545 return result; 546 } 547 548 /** 549 * Creates a new utran_GANSSTimingOfCellType from encoded stream. 550 */ 551 public static utran_GANSSTimingOfCellType fromPerAligned(byte[] encodedBytes) { 552 utran_GANSSTimingOfCellType result = new utran_GANSSTimingOfCellType(); 553 result.decodePerAligned(new BitStreamReader(encodedBytes)); 554 return result; 555 } 556 557 @Override public Iterable<BitStream> encodePerUnaligned() { 558 return super.encodePerUnaligned(); 559 } 560 561 @Override public Iterable<BitStream> encodePerAligned() { 562 return super.encodePerAligned(); 563 } 564 565 @Override public void decodePerUnaligned(BitStreamReader reader) { 566 super.decodePerUnaligned(reader); 567 } 568 569 @Override public void decodePerAligned(BitStreamReader reader) { 570 super.decodePerAligned(reader); 571 } 572 573 @Override public String toString() { 574 return toIndentedString(""); 575 } 576 577 public String toIndentedString(String indent) { 578 return "utran_GANSSTimingOfCellType = " + getInteger() + ";\n"; 579 } 580 } 581 582 583 /* 584 */ 585 586 587 // 588 589 /** 590 */ 591 public static class modeSpecificInfoType extends Asn1Choice { 592 // 593 594 private static final Asn1Tag TAG_modeSpecificInfoType 595 = Asn1Tag.fromClassAndNumber(-1, -1); 596 597 private static final Map<Asn1Tag, Select> tagToSelection = new HashMap<>(); 598 599 private boolean extension; 600 private ChoiceComponent selection; 601 private Asn1Object element; 602 603 static { 604 for (Select select : Select.values()) { 605 for (Asn1Tag tag : select.getPossibleFirstTags()) { 606 Select select0; 607 if ((select0 = tagToSelection.put(tag, select)) != null) { 608 throw new IllegalStateException( 609 "modeSpecificInfoType: " + tag + " maps to both " + select0 + " and " + select); 610 } 611 } 612 } 613 } 614 615 public modeSpecificInfoType() { 616 super(); 617 } 618 619 @Override 620 @Nullable 621 protected Asn1Tag getTag() { 622 return TAG_modeSpecificInfoType; 623 } 624 625 @Override 626 protected boolean isTagImplicit() { 627 return true; 628 } 629 630 public static Collection<Asn1Tag> getPossibleFirstTags() { 631 if (TAG_modeSpecificInfoType != null) { 632 return ImmutableList.of(TAG_modeSpecificInfoType); 633 } else { 634 return tagToSelection.keySet(); 635 } 636 } 637 638 /** 639 * Creates a new modeSpecificInfoType from encoded stream. 640 */ 641 public static modeSpecificInfoType fromPerUnaligned(byte[] encodedBytes) { 642 modeSpecificInfoType result = new modeSpecificInfoType(); 643 result.decodePerUnaligned(new BitStreamReader(encodedBytes)); 644 return result; 645 } 646 647 /** 648 * Creates a new modeSpecificInfoType from encoded stream. 649 */ 650 public static modeSpecificInfoType fromPerAligned(byte[] encodedBytes) { 651 modeSpecificInfoType result = new modeSpecificInfoType(); 652 result.decodePerAligned(new BitStreamReader(encodedBytes)); 653 return result; 654 } 655 656 657 658 @Override protected boolean hasExtensionValue() { 659 return extension; 660 } 661 662 @Override protected Integer getSelectionOrdinal() { 663 return selection.ordinal(); 664 } 665 666 @Nullable 667 @Override 668 protected ChoiceComponent getSelectedComponent() { 669 return selection; 670 } 671 672 @Override protected int getOptionCount() { 673 if (hasExtensionValue()) { 674 return Extend.values().length; 675 } 676 return Select.values().length; 677 } 678 679 protected Asn1Object createAndSetValue(boolean isExtensionValue, 680 int ordinal) { 681 extension = isExtensionValue; 682 if (isExtensionValue) { 683 selection = Extend.values()[ordinal]; 684 } else { 685 selection = Select.values()[ordinal]; 686 } 687 element = selection.createElement(); 688 return element; 689 } 690 691 @Override protected ChoiceComponent createAndSetValue(Asn1Tag tag) { 692 Select select = tagToSelection.get(tag); 693 if (select == null) { 694 throw new IllegalArgumentException("Unknown selection tag: " + tag); 695 } 696 element = select.createElement(); 697 selection = select; 698 extension = false; 699 return select; 700 } 701 702 @Override protected boolean isExtensible() { 703 return false; 704 } 705 706 @Override protected Asn1Object getValue() { 707 return element; 708 } 709 710 711 private static enum Select implements ChoiceComponent { 712 713 $Fdd(Asn1Tag.fromClassAndNumber(2, 0), 714 true) { 715 @Override 716 public Asn1Object createElement() { 717 return new modeSpecificInfoType.fddType(); 718 } 719 720 @Override 721 Collection<Asn1Tag> getPossibleFirstTags() { 722 return tag == null ? modeSpecificInfoType.fddType.getPossibleFirstTags() : ImmutableList.of(tag); 723 } 724 725 @Override 726 String elementIndentedString(Asn1Object element, String indent) { 727 return toString() + " : " + element.toIndentedString(indent); 728 } 729 }, 730 731 $Tdd(Asn1Tag.fromClassAndNumber(2, 1), 732 true) { 733 @Override 734 public Asn1Object createElement() { 735 return new modeSpecificInfoType.tddType(); 736 } 737 738 @Override 739 Collection<Asn1Tag> getPossibleFirstTags() { 740 return tag == null ? modeSpecificInfoType.tddType.getPossibleFirstTags() : ImmutableList.of(tag); 741 } 742 743 @Override 744 String elementIndentedString(Asn1Object element, String indent) { 745 return toString() + " : " + element.toIndentedString(indent); 746 } 747 }, 748 749 ; 750 751 @Nullable final Asn1Tag tag; 752 final boolean isImplicitTagging; 753 754 Select(@Nullable Asn1Tag tag, boolean isImplicitTagging) { 755 this.tag = tag; 756 this.isImplicitTagging = isImplicitTagging; 757 } 758 759 @Override 760 public Asn1Object createElement() { 761 throw new IllegalStateException("Select template error"); 762 } 763 764 @Override 765 @Nullable 766 public Asn1Tag getTag() { 767 return tag; 768 } 769 770 @Override 771 public boolean isImplicitTagging() { 772 return isImplicitTagging; 773 } 774 775 abstract Collection<Asn1Tag> getPossibleFirstTags(); 776 777 abstract String elementIndentedString(Asn1Object element, String indent); 778 } 779 780 /* 781 */ 782 783 784 // 785 786 /** 787 */ 788 public static class fddType extends Asn1Sequence { 789 // 790 791 private static final Asn1Tag TAG_fddType 792 = Asn1Tag.fromClassAndNumber(-1, -1); 793 794 public fddType() { 795 super(); 796 } 797 798 @Override 799 @Nullable 800 protected Asn1Tag getTag() { 801 return TAG_fddType; 802 } 803 804 @Override 805 protected boolean isTagImplicit() { 806 return true; 807 } 808 809 public static Collection<Asn1Tag> getPossibleFirstTags() { 810 if (TAG_fddType != null) { 811 return ImmutableList.of(TAG_fddType); 812 } else { 813 return Asn1Sequence.getPossibleFirstTags(); 814 } 815 } 816 817 /** 818 * Creates a new fddType from encoded stream. 819 */ 820 public static fddType fromPerUnaligned(byte[] encodedBytes) { 821 fddType result = new fddType(); 822 result.decodePerUnaligned(new BitStreamReader(encodedBytes)); 823 return result; 824 } 825 826 /** 827 * Creates a new fddType from encoded stream. 828 */ 829 public static fddType fromPerAligned(byte[] encodedBytes) { 830 fddType result = new fddType(); 831 result.decodePerAligned(new BitStreamReader(encodedBytes)); 832 return result; 833 } 834 835 836 837 @Override protected boolean isExtensible() { 838 return false; 839 } 840 841 @Override public boolean containsExtensionValues() { 842 for (SequenceComponent extensionComponent : getExtensionComponents()) { 843 if (extensionComponent.isExplicitlySet()) return true; 844 } 845 return false; 846 } 847 848 849 private PrimaryCPICH_Info referenceIdentity_; 850 public PrimaryCPICH_Info getReferenceIdentity() { 851 return referenceIdentity_; 852 } 853 /** 854 * @throws ClassCastException if value is not a PrimaryCPICH_Info 855 */ 856 public void setReferenceIdentity(Asn1Object value) { 857 this.referenceIdentity_ = (PrimaryCPICH_Info) value; 858 } 859 public PrimaryCPICH_Info setReferenceIdentityToNewInstance() { 860 referenceIdentity_ = new PrimaryCPICH_Info(); 861 return referenceIdentity_; 862 } 863 864 865 866 867 868 869 @Override public Iterable<? extends SequenceComponent> getComponents() { 870 ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder(); 871 872 builder.add(new SequenceComponent() { 873 Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0); 874 875 @Override public boolean isExplicitlySet() { 876 return getReferenceIdentity() != null; 877 } 878 879 @Override public boolean hasDefaultValue() { 880 return false; 881 } 882 883 @Override public boolean isOptional() { 884 return false; 885 } 886 887 @Override public Asn1Object getComponentValue() { 888 return getReferenceIdentity(); 889 } 890 891 @Override public void setToNewInstance() { 892 setReferenceIdentityToNewInstance(); 893 } 894 895 @Override public Collection<Asn1Tag> getPossibleFirstTags() { 896 return tag == null ? PrimaryCPICH_Info.getPossibleFirstTags() : ImmutableList.of(tag); 897 } 898 899 @Override 900 public Asn1Tag getTag() { 901 return tag; 902 } 903 904 @Override 905 public boolean isImplicitTagging() { 906 return true; 907 } 908 909 @Override public String toIndentedString(String indent) { 910 return "referenceIdentity : " 911 + getReferenceIdentity().toIndentedString(indent); 912 } 913 }); 914 915 return builder.build(); 916 } 917 918 @Override public Iterable<? extends SequenceComponent> 919 getExtensionComponents() { 920 ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder(); 921 922 return builder.build(); 923 } 924 925 926 927 928 929 930 931 @Override public Iterable<BitStream> encodePerUnaligned() { 932 return super.encodePerUnaligned(); 933 } 934 935 @Override public Iterable<BitStream> encodePerAligned() { 936 return super.encodePerAligned(); 937 } 938 939 @Override public void decodePerUnaligned(BitStreamReader reader) { 940 super.decodePerUnaligned(reader); 941 } 942 943 @Override public void decodePerAligned(BitStreamReader reader) { 944 super.decodePerAligned(reader); 945 } 946 947 @Override public String toString() { 948 return toIndentedString(""); 949 } 950 951 public String toIndentedString(String indent) { 952 StringBuilder builder = new StringBuilder(); 953 builder.append("fddType = {\n"); 954 final String internalIndent = indent + " "; 955 for (SequenceComponent component : getComponents()) { 956 if (component.isExplicitlySet()) { 957 builder.append(internalIndent) 958 .append(component.toIndentedString(internalIndent)); 959 } 960 } 961 if (isExtensible()) { 962 builder.append(internalIndent).append("...\n"); 963 for (SequenceComponent component : getExtensionComponents()) { 964 if (component.isExplicitlySet()) { 965 builder.append(internalIndent) 966 .append(component.toIndentedString(internalIndent)); 967 } 968 } 969 } 970 builder.append(indent).append("};\n"); 971 return builder.toString(); 972 } 973 } 974 975 976 public boolean isFdd() { 977 return !hasExtensionValue() && Select.$Fdd == selection; 978 } 979 980 /** 981 * @throws {@code IllegalStateException} if {@code !isFdd}. 982 */ 983 @SuppressWarnings("unchecked") 984 public modeSpecificInfoType.fddType getFdd() { 985 if (!isFdd()) { 986 throw new IllegalStateException("modeSpecificInfoType value not a Fdd"); 987 } 988 return (modeSpecificInfoType.fddType) element; 989 } 990 991 public void setFdd(modeSpecificInfoType.fddType selected) { 992 selection = Select.$Fdd; 993 extension = false; 994 element = selected; 995 } 996 997 public modeSpecificInfoType.fddType setFddToNewInstance() { 998 modeSpecificInfoType.fddType element = new modeSpecificInfoType.fddType(); 999 setFdd(element); 1000 return element; 1001 } 1002 1003 /* 1004 */ 1005 1006 1007 // 1008 1009 /** 1010 */ 1011 public static class tddType extends Asn1Sequence { 1012 // 1013 1014 private static final Asn1Tag TAG_tddType 1015 = Asn1Tag.fromClassAndNumber(-1, -1); 1016 1017 public tddType() { 1018 super(); 1019 } 1020 1021 @Override 1022 @Nullable 1023 protected Asn1Tag getTag() { 1024 return TAG_tddType; 1025 } 1026 1027 @Override 1028 protected boolean isTagImplicit() { 1029 return true; 1030 } 1031 1032 public static Collection<Asn1Tag> getPossibleFirstTags() { 1033 if (TAG_tddType != null) { 1034 return ImmutableList.of(TAG_tddType); 1035 } else { 1036 return Asn1Sequence.getPossibleFirstTags(); 1037 } 1038 } 1039 1040 /** 1041 * Creates a new tddType from encoded stream. 1042 */ 1043 public static tddType fromPerUnaligned(byte[] encodedBytes) { 1044 tddType result = new tddType(); 1045 result.decodePerUnaligned(new BitStreamReader(encodedBytes)); 1046 return result; 1047 } 1048 1049 /** 1050 * Creates a new tddType from encoded stream. 1051 */ 1052 public static tddType fromPerAligned(byte[] encodedBytes) { 1053 tddType result = new tddType(); 1054 result.decodePerAligned(new BitStreamReader(encodedBytes)); 1055 return result; 1056 } 1057 1058 1059 1060 @Override protected boolean isExtensible() { 1061 return false; 1062 } 1063 1064 @Override public boolean containsExtensionValues() { 1065 for (SequenceComponent extensionComponent : getExtensionComponents()) { 1066 if (extensionComponent.isExplicitlySet()) return true; 1067 } 1068 return false; 1069 } 1070 1071 1072 private CellParametersID referenceIdentity_; 1073 public CellParametersID getReferenceIdentity() { 1074 return referenceIdentity_; 1075 } 1076 /** 1077 * @throws ClassCastException if value is not a CellParametersID 1078 */ 1079 public void setReferenceIdentity(Asn1Object value) { 1080 this.referenceIdentity_ = (CellParametersID) value; 1081 } 1082 public CellParametersID setReferenceIdentityToNewInstance() { 1083 referenceIdentity_ = new CellParametersID(); 1084 return referenceIdentity_; 1085 } 1086 1087 1088 1089 1090 1091 1092 @Override public Iterable<? extends SequenceComponent> getComponents() { 1093 ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder(); 1094 1095 builder.add(new SequenceComponent() { 1096 Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0); 1097 1098 @Override public boolean isExplicitlySet() { 1099 return getReferenceIdentity() != null; 1100 } 1101 1102 @Override public boolean hasDefaultValue() { 1103 return false; 1104 } 1105 1106 @Override public boolean isOptional() { 1107 return false; 1108 } 1109 1110 @Override public Asn1Object getComponentValue() { 1111 return getReferenceIdentity(); 1112 } 1113 1114 @Override public void setToNewInstance() { 1115 setReferenceIdentityToNewInstance(); 1116 } 1117 1118 @Override public Collection<Asn1Tag> getPossibleFirstTags() { 1119 return tag == null ? CellParametersID.getPossibleFirstTags() : ImmutableList.of(tag); 1120 } 1121 1122 @Override 1123 public Asn1Tag getTag() { 1124 return tag; 1125 } 1126 1127 @Override 1128 public boolean isImplicitTagging() { 1129 return true; 1130 } 1131 1132 @Override public String toIndentedString(String indent) { 1133 return "referenceIdentity : " 1134 + getReferenceIdentity().toIndentedString(indent); 1135 } 1136 }); 1137 1138 return builder.build(); 1139 } 1140 1141 @Override public Iterable<? extends SequenceComponent> 1142 getExtensionComponents() { 1143 ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder(); 1144 1145 return builder.build(); 1146 } 1147 1148 1149 1150 1151 1152 1153 1154 @Override public Iterable<BitStream> encodePerUnaligned() { 1155 return super.encodePerUnaligned(); 1156 } 1157 1158 @Override public Iterable<BitStream> encodePerAligned() { 1159 return super.encodePerAligned(); 1160 } 1161 1162 @Override public void decodePerUnaligned(BitStreamReader reader) { 1163 super.decodePerUnaligned(reader); 1164 } 1165 1166 @Override public void decodePerAligned(BitStreamReader reader) { 1167 super.decodePerAligned(reader); 1168 } 1169 1170 @Override public String toString() { 1171 return toIndentedString(""); 1172 } 1173 1174 public String toIndentedString(String indent) { 1175 StringBuilder builder = new StringBuilder(); 1176 builder.append("tddType = {\n"); 1177 final String internalIndent = indent + " "; 1178 for (SequenceComponent component : getComponents()) { 1179 if (component.isExplicitlySet()) { 1180 builder.append(internalIndent) 1181 .append(component.toIndentedString(internalIndent)); 1182 } 1183 } 1184 if (isExtensible()) { 1185 builder.append(internalIndent).append("...\n"); 1186 for (SequenceComponent component : getExtensionComponents()) { 1187 if (component.isExplicitlySet()) { 1188 builder.append(internalIndent) 1189 .append(component.toIndentedString(internalIndent)); 1190 } 1191 } 1192 } 1193 builder.append(indent).append("};\n"); 1194 return builder.toString(); 1195 } 1196 } 1197 1198 1199 public boolean isTdd() { 1200 return !hasExtensionValue() && Select.$Tdd == selection; 1201 } 1202 1203 /** 1204 * @throws {@code IllegalStateException} if {@code !isTdd}. 1205 */ 1206 @SuppressWarnings("unchecked") 1207 public modeSpecificInfoType.tddType getTdd() { 1208 if (!isTdd()) { 1209 throw new IllegalStateException("modeSpecificInfoType value not a Tdd"); 1210 } 1211 return (modeSpecificInfoType.tddType) element; 1212 } 1213 1214 public void setTdd(modeSpecificInfoType.tddType selected) { 1215 selection = Select.$Tdd; 1216 extension = false; 1217 element = selected; 1218 } 1219 1220 public modeSpecificInfoType.tddType setTddToNewInstance() { 1221 modeSpecificInfoType.tddType element = new modeSpecificInfoType.tddType(); 1222 setTdd(element); 1223 return element; 1224 } 1225 1226 1227 private static enum Extend implements ChoiceComponent { 1228 1229 ; 1230 @Nullable private final Asn1Tag tag; 1231 private final boolean isImplicitTagging; 1232 1233 Extend(@Nullable Asn1Tag tag, boolean isImplicitTagging) { 1234 this.tag = tag; 1235 this.isImplicitTagging = isImplicitTagging; 1236 } 1237 1238 public Asn1Object createElement() { 1239 throw new IllegalStateException("Extend template error"); 1240 } 1241 1242 @Override 1243 @Nullable 1244 public Asn1Tag getTag() { 1245 return tag; 1246 } 1247 1248 @Override 1249 public boolean isImplicitTagging() { 1250 return isImplicitTagging; 1251 } 1252 1253 String elementIndentedString(Asn1Object element, String indent) { 1254 throw new IllegalStateException("Extend template error"); 1255 } 1256 } 1257 1258 1259 @Override public Iterable<BitStream> encodePerUnaligned() { 1260 return super.encodePerUnaligned(); 1261 } 1262 1263 @Override public Iterable<BitStream> encodePerAligned() { 1264 return super.encodePerAligned(); 1265 } 1266 1267 @Override public void decodePerUnaligned(BitStreamReader reader) { 1268 super.decodePerUnaligned(reader); 1269 } 1270 1271 @Override public void decodePerAligned(BitStreamReader reader) { 1272 super.decodePerAligned(reader); 1273 } 1274 1275 @Override public String toString() { 1276 return toIndentedString(""); 1277 } 1278 1279 private String elementIndentedString(String indent) { 1280 if (element == null) { 1281 return "null;\n"; 1282 } 1283 if (extension) { 1284 return Extend.values()[selection.ordinal()] 1285 .elementIndentedString(element, indent + " "); 1286 } else { 1287 return Select.values()[selection.ordinal()] 1288 .elementIndentedString(element, indent + " "); 1289 } 1290 } 1291 1292 public String toIndentedString(String indent) { 1293 return "modeSpecificInfoType = " + elementIndentedString(indent) + indent + ";\n"; 1294 } 1295 } 1296 1297 1298 /* 1299 */ 1300 1301 1302 // 1303 1304 /** 1305 */ 1306 public static class sfnType extends Asn1Integer { 1307 // 1308 1309 private static final Asn1Tag TAG_sfnType 1310 = Asn1Tag.fromClassAndNumber(-1, -1); 1311 1312 public sfnType() { 1313 super(); 1314 setValueRange("0", "4095"); 1315 1316 } 1317 1318 @Override 1319 @Nullable 1320 protected Asn1Tag getTag() { 1321 return TAG_sfnType; 1322 } 1323 1324 @Override 1325 protected boolean isTagImplicit() { 1326 return true; 1327 } 1328 1329 public static Collection<Asn1Tag> getPossibleFirstTags() { 1330 if (TAG_sfnType != null) { 1331 return ImmutableList.of(TAG_sfnType); 1332 } else { 1333 return Asn1Integer.getPossibleFirstTags(); 1334 } 1335 } 1336 1337 /** 1338 * Creates a new sfnType from encoded stream. 1339 */ 1340 public static sfnType fromPerUnaligned(byte[] encodedBytes) { 1341 sfnType result = new sfnType(); 1342 result.decodePerUnaligned(new BitStreamReader(encodedBytes)); 1343 return result; 1344 } 1345 1346 /** 1347 * Creates a new sfnType from encoded stream. 1348 */ 1349 public static sfnType fromPerAligned(byte[] encodedBytes) { 1350 sfnType result = new sfnType(); 1351 result.decodePerAligned(new BitStreamReader(encodedBytes)); 1352 return result; 1353 } 1354 1355 @Override public Iterable<BitStream> encodePerUnaligned() { 1356 return super.encodePerUnaligned(); 1357 } 1358 1359 @Override public Iterable<BitStream> encodePerAligned() { 1360 return super.encodePerAligned(); 1361 } 1362 1363 @Override public void decodePerUnaligned(BitStreamReader reader) { 1364 super.decodePerUnaligned(reader); 1365 } 1366 1367 @Override public void decodePerAligned(BitStreamReader reader) { 1368 super.decodePerAligned(reader); 1369 } 1370 1371 @Override public String toString() { 1372 return toIndentedString(""); 1373 } 1374 1375 public String toIndentedString(String indent) { 1376 return "sfnType = " + getInteger() + ";\n"; 1377 } 1378 } 1379 1380 1381 /* 1382 */ 1383 1384 1385 // 1386 1387 /** 1388 */ 1389 public static class ganss_TODUncertaintyType extends Asn1Integer { 1390 // 1391 1392 private static final Asn1Tag TAG_ganss_TODUncertaintyType 1393 = Asn1Tag.fromClassAndNumber(-1, -1); 1394 1395 public ganss_TODUncertaintyType() { 1396 super(); 1397 setValueRange("0", "127"); 1398 1399 } 1400 1401 @Override 1402 @Nullable 1403 protected Asn1Tag getTag() { 1404 return TAG_ganss_TODUncertaintyType; 1405 } 1406 1407 @Override 1408 protected boolean isTagImplicit() { 1409 return true; 1410 } 1411 1412 public static Collection<Asn1Tag> getPossibleFirstTags() { 1413 if (TAG_ganss_TODUncertaintyType != null) { 1414 return ImmutableList.of(TAG_ganss_TODUncertaintyType); 1415 } else { 1416 return Asn1Integer.getPossibleFirstTags(); 1417 } 1418 } 1419 1420 /** 1421 * Creates a new ganss_TODUncertaintyType from encoded stream. 1422 */ 1423 public static ganss_TODUncertaintyType fromPerUnaligned(byte[] encodedBytes) { 1424 ganss_TODUncertaintyType result = new ganss_TODUncertaintyType(); 1425 result.decodePerUnaligned(new BitStreamReader(encodedBytes)); 1426 return result; 1427 } 1428 1429 /** 1430 * Creates a new ganss_TODUncertaintyType from encoded stream. 1431 */ 1432 public static ganss_TODUncertaintyType fromPerAligned(byte[] encodedBytes) { 1433 ganss_TODUncertaintyType result = new ganss_TODUncertaintyType(); 1434 result.decodePerAligned(new BitStreamReader(encodedBytes)); 1435 return result; 1436 } 1437 1438 @Override public Iterable<BitStream> encodePerUnaligned() { 1439 return super.encodePerUnaligned(); 1440 } 1441 1442 @Override public Iterable<BitStream> encodePerAligned() { 1443 return super.encodePerAligned(); 1444 } 1445 1446 @Override public void decodePerUnaligned(BitStreamReader reader) { 1447 super.decodePerUnaligned(reader); 1448 } 1449 1450 @Override public void decodePerAligned(BitStreamReader reader) { 1451 super.decodePerAligned(reader); 1452 } 1453 1454 @Override public String toString() { 1455 return toIndentedString(""); 1456 } 1457 1458 public String toIndentedString(String indent) { 1459 return "ganss_TODUncertaintyType = " + getInteger() + ";\n"; 1460 } 1461 } 1462 1463 1464 1465 1466 1467 @Override public Iterable<BitStream> encodePerUnaligned() { 1468 return super.encodePerUnaligned(); 1469 } 1470 1471 @Override public Iterable<BitStream> encodePerAligned() { 1472 return super.encodePerAligned(); 1473 } 1474 1475 @Override public void decodePerUnaligned(BitStreamReader reader) { 1476 super.decodePerUnaligned(reader); 1477 } 1478 1479 @Override public void decodePerAligned(BitStreamReader reader) { 1480 super.decodePerAligned(reader); 1481 } 1482 1483 @Override public String toString() { 1484 return toIndentedString(""); 1485 } 1486 1487 public String toIndentedString(String indent) { 1488 StringBuilder builder = new StringBuilder(); 1489 builder.append("UTRAN_GANSSReferenceTime = {\n"); 1490 final String internalIndent = indent + " "; 1491 for (SequenceComponent component : getComponents()) { 1492 if (component.isExplicitlySet()) { 1493 builder.append(internalIndent) 1494 .append(component.toIndentedString(internalIndent)); 1495 } 1496 } 1497 if (isExtensible()) { 1498 builder.append(internalIndent).append("...\n"); 1499 for (SequenceComponent component : getExtensionComponents()) { 1500 if (component.isExplicitlySet()) { 1501 builder.append(internalIndent) 1502 .append(component.toIndentedString(internalIndent)); 1503 } 1504 } 1505 } 1506 builder.append(indent).append("};\n"); 1507 return builder.toString(); 1508 } 1509 } 1510
