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.Asn1BitString; 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 UmbCellInformation extends Asn1Sequence { 42 // 43 44 private static final Asn1Tag TAG_UmbCellInformation 45 = Asn1Tag.fromClassAndNumber(-1, -1); 46 47 public UmbCellInformation() { 48 super(); 49 } 50 51 @Override 52 @Nullable 53 protected Asn1Tag getTag() { 54 return TAG_UmbCellInformation; 55 } 56 57 @Override 58 protected boolean isTagImplicit() { 59 return true; 60 } 61 62 public static Collection<Asn1Tag> getPossibleFirstTags() { 63 if (TAG_UmbCellInformation != null) { 64 return ImmutableList.of(TAG_UmbCellInformation); 65 } else { 66 return Asn1Sequence.getPossibleFirstTags(); 67 } 68 } 69 70 /** 71 * Creates a new UmbCellInformation from encoded stream. 72 */ 73 public static UmbCellInformation fromPerUnaligned(byte[] encodedBytes) { 74 UmbCellInformation result = new UmbCellInformation(); 75 result.decodePerUnaligned(new BitStreamReader(encodedBytes)); 76 return result; 77 } 78 79 /** 80 * Creates a new UmbCellInformation from encoded stream. 81 */ 82 public static UmbCellInformation fromPerAligned(byte[] encodedBytes) { 83 UmbCellInformation result = new UmbCellInformation(); 84 result.decodePerAligned(new BitStreamReader(encodedBytes)); 85 return result; 86 } 87 88 89 90 @Override protected boolean isExtensible() { 91 return true; 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 UmbCellInformation.refSECTORIDType refSECTORID_; 103 public UmbCellInformation.refSECTORIDType getRefSECTORID() { 104 return refSECTORID_; 105 } 106 /** 107 * @throws ClassCastException if value is not a UmbCellInformation.refSECTORIDType 108 */ 109 public void setRefSECTORID(Asn1Object value) { 110 this.refSECTORID_ = (UmbCellInformation.refSECTORIDType) value; 111 } 112 public UmbCellInformation.refSECTORIDType setRefSECTORIDToNewInstance() { 113 refSECTORID_ = new UmbCellInformation.refSECTORIDType(); 114 return refSECTORID_; 115 } 116 117 private UmbCellInformation.refMCCType refMCC_; 118 public UmbCellInformation.refMCCType getRefMCC() { 119 return refMCC_; 120 } 121 /** 122 * @throws ClassCastException if value is not a UmbCellInformation.refMCCType 123 */ 124 public void setRefMCC(Asn1Object value) { 125 this.refMCC_ = (UmbCellInformation.refMCCType) value; 126 } 127 public UmbCellInformation.refMCCType setRefMCCToNewInstance() { 128 refMCC_ = new UmbCellInformation.refMCCType(); 129 return refMCC_; 130 } 131 132 private UmbCellInformation.refMNCType refMNC_; 133 public UmbCellInformation.refMNCType getRefMNC() { 134 return refMNC_; 135 } 136 /** 137 * @throws ClassCastException if value is not a UmbCellInformation.refMNCType 138 */ 139 public void setRefMNC(Asn1Object value) { 140 this.refMNC_ = (UmbCellInformation.refMNCType) value; 141 } 142 public UmbCellInformation.refMNCType setRefMNCToNewInstance() { 143 refMNC_ = new UmbCellInformation.refMNCType(); 144 return refMNC_; 145 } 146 147 private UmbCellInformation.refBASELATType refBASELAT_; 148 public UmbCellInformation.refBASELATType getRefBASELAT() { 149 return refBASELAT_; 150 } 151 /** 152 * @throws ClassCastException if value is not a UmbCellInformation.refBASELATType 153 */ 154 public void setRefBASELAT(Asn1Object value) { 155 this.refBASELAT_ = (UmbCellInformation.refBASELATType) value; 156 } 157 public UmbCellInformation.refBASELATType setRefBASELATToNewInstance() { 158 refBASELAT_ = new UmbCellInformation.refBASELATType(); 159 return refBASELAT_; 160 } 161 162 private UmbCellInformation.reBASELONGType reBASELONG_; 163 public UmbCellInformation.reBASELONGType getReBASELONG() { 164 return reBASELONG_; 165 } 166 /** 167 * @throws ClassCastException if value is not a UmbCellInformation.reBASELONGType 168 */ 169 public void setReBASELONG(Asn1Object value) { 170 this.reBASELONG_ = (UmbCellInformation.reBASELONGType) value; 171 } 172 public UmbCellInformation.reBASELONGType setReBASELONGToNewInstance() { 173 reBASELONG_ = new UmbCellInformation.reBASELONGType(); 174 return reBASELONG_; 175 } 176 177 private UmbCellInformation.refWeekNumberType refWeekNumber_; 178 public UmbCellInformation.refWeekNumberType getRefWeekNumber() { 179 return refWeekNumber_; 180 } 181 /** 182 * @throws ClassCastException if value is not a UmbCellInformation.refWeekNumberType 183 */ 184 public void setRefWeekNumber(Asn1Object value) { 185 this.refWeekNumber_ = (UmbCellInformation.refWeekNumberType) value; 186 } 187 public UmbCellInformation.refWeekNumberType setRefWeekNumberToNewInstance() { 188 refWeekNumber_ = new UmbCellInformation.refWeekNumberType(); 189 return refWeekNumber_; 190 } 191 192 private UmbCellInformation.refSecondsType refSeconds_; 193 public UmbCellInformation.refSecondsType getRefSeconds() { 194 return refSeconds_; 195 } 196 /** 197 * @throws ClassCastException if value is not a UmbCellInformation.refSecondsType 198 */ 199 public void setRefSeconds(Asn1Object value) { 200 this.refSeconds_ = (UmbCellInformation.refSecondsType) value; 201 } 202 public UmbCellInformation.refSecondsType setRefSecondsToNewInstance() { 203 refSeconds_ = new UmbCellInformation.refSecondsType(); 204 return refSeconds_; 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 getRefSECTORID() != 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 getRefSECTORID(); 232 } 233 234 @Override public void setToNewInstance() { 235 setRefSECTORIDToNewInstance(); 236 } 237 238 @Override public Collection<Asn1Tag> getPossibleFirstTags() { 239 return tag == null ? UmbCellInformation.refSECTORIDType.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 "refSECTORID : " 254 + getRefSECTORID().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 getRefMCC() != 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 getRefMCC(); 275 } 276 277 @Override public void setToNewInstance() { 278 setRefMCCToNewInstance(); 279 } 280 281 @Override public Collection<Asn1Tag> getPossibleFirstTags() { 282 return tag == null ? UmbCellInformation.refMCCType.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 "refMCC : " 297 + getRefMCC().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 getRefMNC() != 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 getRefMNC(); 318 } 319 320 @Override public void setToNewInstance() { 321 setRefMNCToNewInstance(); 322 } 323 324 @Override public Collection<Asn1Tag> getPossibleFirstTags() { 325 return tag == null ? UmbCellInformation.refMNCType.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 "refMNC : " 340 + getRefMNC().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 getRefBASELAT() != 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 getRefBASELAT(); 361 } 362 363 @Override public void setToNewInstance() { 364 setRefBASELATToNewInstance(); 365 } 366 367 @Override public Collection<Asn1Tag> getPossibleFirstTags() { 368 return tag == null ? UmbCellInformation.refBASELATType.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 "refBASELAT : " 383 + getRefBASELAT().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 getReBASELONG() != 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 getReBASELONG(); 404 } 405 406 @Override public void setToNewInstance() { 407 setReBASELONGToNewInstance(); 408 } 409 410 @Override public Collection<Asn1Tag> getPossibleFirstTags() { 411 return tag == null ? UmbCellInformation.reBASELONGType.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 "reBASELONG : " 426 + getReBASELONG().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 getRefWeekNumber() != 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 getRefWeekNumber(); 447 } 448 449 @Override public void setToNewInstance() { 450 setRefWeekNumberToNewInstance(); 451 } 452 453 @Override public Collection<Asn1Tag> getPossibleFirstTags() { 454 return tag == null ? UmbCellInformation.refWeekNumberType.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 "refWeekNumber : " 469 + getRefWeekNumber().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 getRefSeconds() != 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 getRefSeconds(); 490 } 491 492 @Override public void setToNewInstance() { 493 setRefSecondsToNewInstance(); 494 } 495 496 @Override public Collection<Asn1Tag> getPossibleFirstTags() { 497 return tag == null ? UmbCellInformation.refSecondsType.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 "refSeconds : " 512 + getRefSeconds().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 public static class refSECTORIDType extends Asn1BitString { 536 // 537 538 private static final Asn1Tag TAG_refSECTORIDType 539 = Asn1Tag.fromClassAndNumber(-1, -1); 540 541 public refSECTORIDType() { 542 super(); 543 setMinSize(128); 544 setMaxSize(128); 545 546 } 547 548 @Override 549 @Nullable 550 protected Asn1Tag getTag() { 551 return TAG_refSECTORIDType; 552 } 553 554 @Override 555 protected boolean isTagImplicit() { 556 return true; 557 } 558 559 public static Collection<Asn1Tag> getPossibleFirstTags() { 560 if (TAG_refSECTORIDType != null) { 561 return ImmutableList.of(TAG_refSECTORIDType); 562 } else { 563 return Asn1BitString.getPossibleFirstTags(); 564 } 565 } 566 567 /** 568 * Creates a new refSECTORIDType from encoded stream. 569 */ 570 public static refSECTORIDType fromPerUnaligned(byte[] encodedBytes) { 571 refSECTORIDType result = new refSECTORIDType(); 572 result.decodePerUnaligned(new BitStreamReader(encodedBytes)); 573 return result; 574 } 575 576 /** 577 * Creates a new refSECTORIDType from encoded stream. 578 */ 579 public static refSECTORIDType fromPerAligned(byte[] encodedBytes) { 580 refSECTORIDType result = new refSECTORIDType(); 581 result.decodePerAligned(new BitStreamReader(encodedBytes)); 582 return result; 583 } 584 585 @Override public Iterable<BitStream> encodePerUnaligned() { 586 return super.encodePerUnaligned(); 587 } 588 589 @Override public Iterable<BitStream> encodePerAligned() { 590 return super.encodePerAligned(); 591 } 592 593 @Override public void decodePerUnaligned(BitStreamReader reader) { 594 super.decodePerUnaligned(reader); 595 } 596 597 @Override public void decodePerAligned(BitStreamReader reader) { 598 super.decodePerAligned(reader); 599 } 600 601 @Override public String toString() { 602 return toIndentedString(""); 603 } 604 605 public String toIndentedString(String indent) { 606 return "refSECTORIDType = " + getValue() + ";\n"; 607 } 608 } 609 610 611 /* 612 */ 613 614 615 // 616 617 /** 618 */ 619 public static class refMCCType extends Asn1Integer { 620 // 621 622 private static final Asn1Tag TAG_refMCCType 623 = Asn1Tag.fromClassAndNumber(-1, -1); 624 625 public refMCCType() { 626 super(); 627 setValueRange("0", "999"); 628 629 } 630 631 @Override 632 @Nullable 633 protected Asn1Tag getTag() { 634 return TAG_refMCCType; 635 } 636 637 @Override 638 protected boolean isTagImplicit() { 639 return true; 640 } 641 642 public static Collection<Asn1Tag> getPossibleFirstTags() { 643 if (TAG_refMCCType != null) { 644 return ImmutableList.of(TAG_refMCCType); 645 } else { 646 return Asn1Integer.getPossibleFirstTags(); 647 } 648 } 649 650 /** 651 * Creates a new refMCCType from encoded stream. 652 */ 653 public static refMCCType fromPerUnaligned(byte[] encodedBytes) { 654 refMCCType result = new refMCCType(); 655 result.decodePerUnaligned(new BitStreamReader(encodedBytes)); 656 return result; 657 } 658 659 /** 660 * Creates a new refMCCType from encoded stream. 661 */ 662 public static refMCCType fromPerAligned(byte[] encodedBytes) { 663 refMCCType result = new refMCCType(); 664 result.decodePerAligned(new BitStreamReader(encodedBytes)); 665 return result; 666 } 667 668 @Override public Iterable<BitStream> encodePerUnaligned() { 669 return super.encodePerUnaligned(); 670 } 671 672 @Override public Iterable<BitStream> encodePerAligned() { 673 return super.encodePerAligned(); 674 } 675 676 @Override public void decodePerUnaligned(BitStreamReader reader) { 677 super.decodePerUnaligned(reader); 678 } 679 680 @Override public void decodePerAligned(BitStreamReader reader) { 681 super.decodePerAligned(reader); 682 } 683 684 @Override public String toString() { 685 return toIndentedString(""); 686 } 687 688 public String toIndentedString(String indent) { 689 return "refMCCType = " + getInteger() + ";\n"; 690 } 691 } 692 693 694 /* 695 */ 696 697 698 // 699 700 /** 701 */ 702 public static class refMNCType extends Asn1Integer { 703 // 704 705 private static final Asn1Tag TAG_refMNCType 706 = Asn1Tag.fromClassAndNumber(-1, -1); 707 708 public refMNCType() { 709 super(); 710 setValueRange("0", "999"); 711 712 } 713 714 @Override 715 @Nullable 716 protected Asn1Tag getTag() { 717 return TAG_refMNCType; 718 } 719 720 @Override 721 protected boolean isTagImplicit() { 722 return true; 723 } 724 725 public static Collection<Asn1Tag> getPossibleFirstTags() { 726 if (TAG_refMNCType != null) { 727 return ImmutableList.of(TAG_refMNCType); 728 } else { 729 return Asn1Integer.getPossibleFirstTags(); 730 } 731 } 732 733 /** 734 * Creates a new refMNCType from encoded stream. 735 */ 736 public static refMNCType fromPerUnaligned(byte[] encodedBytes) { 737 refMNCType result = new refMNCType(); 738 result.decodePerUnaligned(new BitStreamReader(encodedBytes)); 739 return result; 740 } 741 742 /** 743 * Creates a new refMNCType from encoded stream. 744 */ 745 public static refMNCType fromPerAligned(byte[] encodedBytes) { 746 refMNCType result = new refMNCType(); 747 result.decodePerAligned(new BitStreamReader(encodedBytes)); 748 return result; 749 } 750 751 @Override public Iterable<BitStream> encodePerUnaligned() { 752 return super.encodePerUnaligned(); 753 } 754 755 @Override public Iterable<BitStream> encodePerAligned() { 756 return super.encodePerAligned(); 757 } 758 759 @Override public void decodePerUnaligned(BitStreamReader reader) { 760 super.decodePerUnaligned(reader); 761 } 762 763 @Override public void decodePerAligned(BitStreamReader reader) { 764 super.decodePerAligned(reader); 765 } 766 767 @Override public String toString() { 768 return toIndentedString(""); 769 } 770 771 public String toIndentedString(String indent) { 772 return "refMNCType = " + getInteger() + ";\n"; 773 } 774 } 775 776 777 /* 778 */ 779 780 781 // 782 783 /** 784 */ 785 public static class refBASELATType extends Asn1Integer { 786 // 787 788 private static final Asn1Tag TAG_refBASELATType 789 = Asn1Tag.fromClassAndNumber(-1, -1); 790 791 public refBASELATType() { 792 super(); 793 setValueRange("0", "4194303"); 794 795 } 796 797 @Override 798 @Nullable 799 protected Asn1Tag getTag() { 800 return TAG_refBASELATType; 801 } 802 803 @Override 804 protected boolean isTagImplicit() { 805 return true; 806 } 807 808 public static Collection<Asn1Tag> getPossibleFirstTags() { 809 if (TAG_refBASELATType != null) { 810 return ImmutableList.of(TAG_refBASELATType); 811 } else { 812 return Asn1Integer.getPossibleFirstTags(); 813 } 814 } 815 816 /** 817 * Creates a new refBASELATType from encoded stream. 818 */ 819 public static refBASELATType fromPerUnaligned(byte[] encodedBytes) { 820 refBASELATType result = new refBASELATType(); 821 result.decodePerUnaligned(new BitStreamReader(encodedBytes)); 822 return result; 823 } 824 825 /** 826 * Creates a new refBASELATType from encoded stream. 827 */ 828 public static refBASELATType fromPerAligned(byte[] encodedBytes) { 829 refBASELATType result = new refBASELATType(); 830 result.decodePerAligned(new BitStreamReader(encodedBytes)); 831 return result; 832 } 833 834 @Override public Iterable<BitStream> encodePerUnaligned() { 835 return super.encodePerUnaligned(); 836 } 837 838 @Override public Iterable<BitStream> encodePerAligned() { 839 return super.encodePerAligned(); 840 } 841 842 @Override public void decodePerUnaligned(BitStreamReader reader) { 843 super.decodePerUnaligned(reader); 844 } 845 846 @Override public void decodePerAligned(BitStreamReader reader) { 847 super.decodePerAligned(reader); 848 } 849 850 @Override public String toString() { 851 return toIndentedString(""); 852 } 853 854 public String toIndentedString(String indent) { 855 return "refBASELATType = " + getInteger() + ";\n"; 856 } 857 } 858 859 860 /* 861 */ 862 863 864 // 865 866 /** 867 */ 868 public static class reBASELONGType extends Asn1Integer { 869 // 870 871 private static final Asn1Tag TAG_reBASELONGType 872 = Asn1Tag.fromClassAndNumber(-1, -1); 873 874 public reBASELONGType() { 875 super(); 876 setValueRange("0", "8388607"); 877 878 } 879 880 @Override 881 @Nullable 882 protected Asn1Tag getTag() { 883 return TAG_reBASELONGType; 884 } 885 886 @Override 887 protected boolean isTagImplicit() { 888 return true; 889 } 890 891 public static Collection<Asn1Tag> getPossibleFirstTags() { 892 if (TAG_reBASELONGType != null) { 893 return ImmutableList.of(TAG_reBASELONGType); 894 } else { 895 return Asn1Integer.getPossibleFirstTags(); 896 } 897 } 898 899 /** 900 * Creates a new reBASELONGType from encoded stream. 901 */ 902 public static reBASELONGType fromPerUnaligned(byte[] encodedBytes) { 903 reBASELONGType result = new reBASELONGType(); 904 result.decodePerUnaligned(new BitStreamReader(encodedBytes)); 905 return result; 906 } 907 908 /** 909 * Creates a new reBASELONGType from encoded stream. 910 */ 911 public static reBASELONGType fromPerAligned(byte[] encodedBytes) { 912 reBASELONGType result = new reBASELONGType(); 913 result.decodePerAligned(new BitStreamReader(encodedBytes)); 914 return result; 915 } 916 917 @Override public Iterable<BitStream> encodePerUnaligned() { 918 return super.encodePerUnaligned(); 919 } 920 921 @Override public Iterable<BitStream> encodePerAligned() { 922 return super.encodePerAligned(); 923 } 924 925 @Override public void decodePerUnaligned(BitStreamReader reader) { 926 super.decodePerUnaligned(reader); 927 } 928 929 @Override public void decodePerAligned(BitStreamReader reader) { 930 super.decodePerAligned(reader); 931 } 932 933 @Override public String toString() { 934 return toIndentedString(""); 935 } 936 937 public String toIndentedString(String indent) { 938 return "reBASELONGType = " + getInteger() + ";\n"; 939 } 940 } 941 942 943 /* 944 */ 945 946 947 // 948 949 /** 950 */ 951 public static class refWeekNumberType extends Asn1Integer { 952 // 953 954 private static final Asn1Tag TAG_refWeekNumberType 955 = Asn1Tag.fromClassAndNumber(-1, -1); 956 957 public refWeekNumberType() { 958 super(); 959 setValueRange("0", "65535"); 960 961 } 962 963 @Override 964 @Nullable 965 protected Asn1Tag getTag() { 966 return TAG_refWeekNumberType; 967 } 968 969 @Override 970 protected boolean isTagImplicit() { 971 return true; 972 } 973 974 public static Collection<Asn1Tag> getPossibleFirstTags() { 975 if (TAG_refWeekNumberType != null) { 976 return ImmutableList.of(TAG_refWeekNumberType); 977 } else { 978 return Asn1Integer.getPossibleFirstTags(); 979 } 980 } 981 982 /** 983 * Creates a new refWeekNumberType from encoded stream. 984 */ 985 public static refWeekNumberType fromPerUnaligned(byte[] encodedBytes) { 986 refWeekNumberType result = new refWeekNumberType(); 987 result.decodePerUnaligned(new BitStreamReader(encodedBytes)); 988 return result; 989 } 990 991 /** 992 * Creates a new refWeekNumberType from encoded stream. 993 */ 994 public static refWeekNumberType fromPerAligned(byte[] encodedBytes) { 995 refWeekNumberType result = new refWeekNumberType(); 996 result.decodePerAligned(new BitStreamReader(encodedBytes)); 997 return result; 998 } 999 1000 @Override public Iterable<BitStream> encodePerUnaligned() { 1001 return super.encodePerUnaligned(); 1002 } 1003 1004 @Override public Iterable<BitStream> encodePerAligned() { 1005 return super.encodePerAligned(); 1006 } 1007 1008 @Override public void decodePerUnaligned(BitStreamReader reader) { 1009 super.decodePerUnaligned(reader); 1010 } 1011 1012 @Override public void decodePerAligned(BitStreamReader reader) { 1013 super.decodePerAligned(reader); 1014 } 1015 1016 @Override public String toString() { 1017 return toIndentedString(""); 1018 } 1019 1020 public String toIndentedString(String indent) { 1021 return "refWeekNumberType = " + getInteger() + ";\n"; 1022 } 1023 } 1024 1025 1026 /* 1027 */ 1028 1029 1030 // 1031 1032 /** 1033 */ 1034 public static class refSecondsType extends Asn1Integer { 1035 // 1036 1037 private static final Asn1Tag TAG_refSecondsType 1038 = Asn1Tag.fromClassAndNumber(-1, -1); 1039 1040 public refSecondsType() { 1041 super(); 1042 setValueRange("0", "4194303"); 1043 1044 } 1045 1046 @Override 1047 @Nullable 1048 protected Asn1Tag getTag() { 1049 return TAG_refSecondsType; 1050 } 1051 1052 @Override 1053 protected boolean isTagImplicit() { 1054 return true; 1055 } 1056 1057 public static Collection<Asn1Tag> getPossibleFirstTags() { 1058 if (TAG_refSecondsType != null) { 1059 return ImmutableList.of(TAG_refSecondsType); 1060 } else { 1061 return Asn1Integer.getPossibleFirstTags(); 1062 } 1063 } 1064 1065 /** 1066 * Creates a new refSecondsType from encoded stream. 1067 */ 1068 public static refSecondsType fromPerUnaligned(byte[] encodedBytes) { 1069 refSecondsType result = new refSecondsType(); 1070 result.decodePerUnaligned(new BitStreamReader(encodedBytes)); 1071 return result; 1072 } 1073 1074 /** 1075 * Creates a new refSecondsType from encoded stream. 1076 */ 1077 public static refSecondsType fromPerAligned(byte[] encodedBytes) { 1078 refSecondsType result = new refSecondsType(); 1079 result.decodePerAligned(new BitStreamReader(encodedBytes)); 1080 return result; 1081 } 1082 1083 @Override public Iterable<BitStream> encodePerUnaligned() { 1084 return super.encodePerUnaligned(); 1085 } 1086 1087 @Override public Iterable<BitStream> encodePerAligned() { 1088 return super.encodePerAligned(); 1089 } 1090 1091 @Override public void decodePerUnaligned(BitStreamReader reader) { 1092 super.decodePerUnaligned(reader); 1093 } 1094 1095 @Override public void decodePerAligned(BitStreamReader reader) { 1096 super.decodePerAligned(reader); 1097 } 1098 1099 @Override public String toString() { 1100 return toIndentedString(""); 1101 } 1102 1103 public String toIndentedString(String indent) { 1104 return "refSecondsType = " + getInteger() + ";\n"; 1105 } 1106 } 1107 1108 1109 1110 1111 1112 @Override public Iterable<BitStream> encodePerUnaligned() { 1113 return super.encodePerUnaligned(); 1114 } 1115 1116 @Override public Iterable<BitStream> encodePerAligned() { 1117 return super.encodePerAligned(); 1118 } 1119 1120 @Override public void decodePerUnaligned(BitStreamReader reader) { 1121 super.decodePerUnaligned(reader); 1122 } 1123 1124 @Override public void decodePerAligned(BitStreamReader reader) { 1125 super.decodePerAligned(reader); 1126 } 1127 1128 @Override public String toString() { 1129 return toIndentedString(""); 1130 } 1131 1132 public String toIndentedString(String indent) { 1133 StringBuilder builder = new StringBuilder(); 1134 builder.append("UmbCellInformation = {\n"); 1135 final String internalIndent = indent + " "; 1136 for (SequenceComponent component : getComponents()) { 1137 if (component.isExplicitlySet()) { 1138 builder.append(internalIndent) 1139 .append(component.toIndentedString(internalIndent)); 1140 } 1141 } 1142 if (isExtensible()) { 1143 builder.append(internalIndent).append("...\n"); 1144 for (SequenceComponent component : getExtensionComponents()) { 1145 if (component.isExplicitlySet()) { 1146 builder.append(internalIndent) 1147 .append(component.toIndentedString(internalIndent)); 1148 } 1149 } 1150 } 1151 builder.append(indent).append("};\n"); 1152 return builder.toString(); 1153 } 1154 } 1155
