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 NavModel_KeplerianSet extends Asn1Sequence { 41 // 42 43 private static final Asn1Tag TAG_NavModel_KeplerianSet 44 = Asn1Tag.fromClassAndNumber(-1, -1); 45 46 public NavModel_KeplerianSet() { 47 super(); 48 } 49 50 @Override 51 @Nullable 52 protected Asn1Tag getTag() { 53 return TAG_NavModel_KeplerianSet; 54 } 55 56 @Override 57 protected boolean isTagImplicit() { 58 return true; 59 } 60 61 public static Collection<Asn1Tag> getPossibleFirstTags() { 62 if (TAG_NavModel_KeplerianSet != null) { 63 return ImmutableList.of(TAG_NavModel_KeplerianSet); 64 } else { 65 return Asn1Sequence.getPossibleFirstTags(); 66 } 67 } 68 69 /** 70 * Creates a new NavModel_KeplerianSet from encoded stream. 71 */ 72 public static NavModel_KeplerianSet fromPerUnaligned(byte[] encodedBytes) { 73 NavModel_KeplerianSet result = new NavModel_KeplerianSet(); 74 result.decodePerUnaligned(new BitStreamReader(encodedBytes)); 75 return result; 76 } 77 78 /** 79 * Creates a new NavModel_KeplerianSet from encoded stream. 80 */ 81 public static NavModel_KeplerianSet fromPerAligned(byte[] encodedBytes) { 82 NavModel_KeplerianSet result = new NavModel_KeplerianSet(); 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 NavModel_KeplerianSet.keplerToeType keplerToe_; 102 public NavModel_KeplerianSet.keplerToeType getKeplerToe() { 103 return keplerToe_; 104 } 105 /** 106 * @throws ClassCastException if value is not a NavModel_KeplerianSet.keplerToeType 107 */ 108 public void setKeplerToe(Asn1Object value) { 109 this.keplerToe_ = (NavModel_KeplerianSet.keplerToeType) value; 110 } 111 public NavModel_KeplerianSet.keplerToeType setKeplerToeToNewInstance() { 112 keplerToe_ = new NavModel_KeplerianSet.keplerToeType(); 113 return keplerToe_; 114 } 115 116 private NavModel_KeplerianSet.keplerWType keplerW_; 117 public NavModel_KeplerianSet.keplerWType getKeplerW() { 118 return keplerW_; 119 } 120 /** 121 * @throws ClassCastException if value is not a NavModel_KeplerianSet.keplerWType 122 */ 123 public void setKeplerW(Asn1Object value) { 124 this.keplerW_ = (NavModel_KeplerianSet.keplerWType) value; 125 } 126 public NavModel_KeplerianSet.keplerWType setKeplerWToNewInstance() { 127 keplerW_ = new NavModel_KeplerianSet.keplerWType(); 128 return keplerW_; 129 } 130 131 private NavModel_KeplerianSet.keplerDeltaNType keplerDeltaN_; 132 public NavModel_KeplerianSet.keplerDeltaNType getKeplerDeltaN() { 133 return keplerDeltaN_; 134 } 135 /** 136 * @throws ClassCastException if value is not a NavModel_KeplerianSet.keplerDeltaNType 137 */ 138 public void setKeplerDeltaN(Asn1Object value) { 139 this.keplerDeltaN_ = (NavModel_KeplerianSet.keplerDeltaNType) value; 140 } 141 public NavModel_KeplerianSet.keplerDeltaNType setKeplerDeltaNToNewInstance() { 142 keplerDeltaN_ = new NavModel_KeplerianSet.keplerDeltaNType(); 143 return keplerDeltaN_; 144 } 145 146 private NavModel_KeplerianSet.keplerM0Type keplerM0_; 147 public NavModel_KeplerianSet.keplerM0Type getKeplerM0() { 148 return keplerM0_; 149 } 150 /** 151 * @throws ClassCastException if value is not a NavModel_KeplerianSet.keplerM0Type 152 */ 153 public void setKeplerM0(Asn1Object value) { 154 this.keplerM0_ = (NavModel_KeplerianSet.keplerM0Type) value; 155 } 156 public NavModel_KeplerianSet.keplerM0Type setKeplerM0ToNewInstance() { 157 keplerM0_ = new NavModel_KeplerianSet.keplerM0Type(); 158 return keplerM0_; 159 } 160 161 private NavModel_KeplerianSet.keplerOmegaDotType keplerOmegaDot_; 162 public NavModel_KeplerianSet.keplerOmegaDotType getKeplerOmegaDot() { 163 return keplerOmegaDot_; 164 } 165 /** 166 * @throws ClassCastException if value is not a NavModel_KeplerianSet.keplerOmegaDotType 167 */ 168 public void setKeplerOmegaDot(Asn1Object value) { 169 this.keplerOmegaDot_ = (NavModel_KeplerianSet.keplerOmegaDotType) value; 170 } 171 public NavModel_KeplerianSet.keplerOmegaDotType setKeplerOmegaDotToNewInstance() { 172 keplerOmegaDot_ = new NavModel_KeplerianSet.keplerOmegaDotType(); 173 return keplerOmegaDot_; 174 } 175 176 private NavModel_KeplerianSet.keplerEType keplerE_; 177 public NavModel_KeplerianSet.keplerEType getKeplerE() { 178 return keplerE_; 179 } 180 /** 181 * @throws ClassCastException if value is not a NavModel_KeplerianSet.keplerEType 182 */ 183 public void setKeplerE(Asn1Object value) { 184 this.keplerE_ = (NavModel_KeplerianSet.keplerEType) value; 185 } 186 public NavModel_KeplerianSet.keplerEType setKeplerEToNewInstance() { 187 keplerE_ = new NavModel_KeplerianSet.keplerEType(); 188 return keplerE_; 189 } 190 191 private NavModel_KeplerianSet.keplerIDotType keplerIDot_; 192 public NavModel_KeplerianSet.keplerIDotType getKeplerIDot() { 193 return keplerIDot_; 194 } 195 /** 196 * @throws ClassCastException if value is not a NavModel_KeplerianSet.keplerIDotType 197 */ 198 public void setKeplerIDot(Asn1Object value) { 199 this.keplerIDot_ = (NavModel_KeplerianSet.keplerIDotType) value; 200 } 201 public NavModel_KeplerianSet.keplerIDotType setKeplerIDotToNewInstance() { 202 keplerIDot_ = new NavModel_KeplerianSet.keplerIDotType(); 203 return keplerIDot_; 204 } 205 206 private NavModel_KeplerianSet.keplerAPowerHalfType keplerAPowerHalf_; 207 public NavModel_KeplerianSet.keplerAPowerHalfType getKeplerAPowerHalf() { 208 return keplerAPowerHalf_; 209 } 210 /** 211 * @throws ClassCastException if value is not a NavModel_KeplerianSet.keplerAPowerHalfType 212 */ 213 public void setKeplerAPowerHalf(Asn1Object value) { 214 this.keplerAPowerHalf_ = (NavModel_KeplerianSet.keplerAPowerHalfType) value; 215 } 216 public NavModel_KeplerianSet.keplerAPowerHalfType setKeplerAPowerHalfToNewInstance() { 217 keplerAPowerHalf_ = new NavModel_KeplerianSet.keplerAPowerHalfType(); 218 return keplerAPowerHalf_; 219 } 220 221 private NavModel_KeplerianSet.keplerI0Type keplerI0_; 222 public NavModel_KeplerianSet.keplerI0Type getKeplerI0() { 223 return keplerI0_; 224 } 225 /** 226 * @throws ClassCastException if value is not a NavModel_KeplerianSet.keplerI0Type 227 */ 228 public void setKeplerI0(Asn1Object value) { 229 this.keplerI0_ = (NavModel_KeplerianSet.keplerI0Type) value; 230 } 231 public NavModel_KeplerianSet.keplerI0Type setKeplerI0ToNewInstance() { 232 keplerI0_ = new NavModel_KeplerianSet.keplerI0Type(); 233 return keplerI0_; 234 } 235 236 private NavModel_KeplerianSet.keplerOmega0Type keplerOmega0_; 237 public NavModel_KeplerianSet.keplerOmega0Type getKeplerOmega0() { 238 return keplerOmega0_; 239 } 240 /** 241 * @throws ClassCastException if value is not a NavModel_KeplerianSet.keplerOmega0Type 242 */ 243 public void setKeplerOmega0(Asn1Object value) { 244 this.keplerOmega0_ = (NavModel_KeplerianSet.keplerOmega0Type) value; 245 } 246 public NavModel_KeplerianSet.keplerOmega0Type setKeplerOmega0ToNewInstance() { 247 keplerOmega0_ = new NavModel_KeplerianSet.keplerOmega0Type(); 248 return keplerOmega0_; 249 } 250 251 private NavModel_KeplerianSet.keplerCrsType keplerCrs_; 252 public NavModel_KeplerianSet.keplerCrsType getKeplerCrs() { 253 return keplerCrs_; 254 } 255 /** 256 * @throws ClassCastException if value is not a NavModel_KeplerianSet.keplerCrsType 257 */ 258 public void setKeplerCrs(Asn1Object value) { 259 this.keplerCrs_ = (NavModel_KeplerianSet.keplerCrsType) value; 260 } 261 public NavModel_KeplerianSet.keplerCrsType setKeplerCrsToNewInstance() { 262 keplerCrs_ = new NavModel_KeplerianSet.keplerCrsType(); 263 return keplerCrs_; 264 } 265 266 private NavModel_KeplerianSet.keplerCisType keplerCis_; 267 public NavModel_KeplerianSet.keplerCisType getKeplerCis() { 268 return keplerCis_; 269 } 270 /** 271 * @throws ClassCastException if value is not a NavModel_KeplerianSet.keplerCisType 272 */ 273 public void setKeplerCis(Asn1Object value) { 274 this.keplerCis_ = (NavModel_KeplerianSet.keplerCisType) value; 275 } 276 public NavModel_KeplerianSet.keplerCisType setKeplerCisToNewInstance() { 277 keplerCis_ = new NavModel_KeplerianSet.keplerCisType(); 278 return keplerCis_; 279 } 280 281 private NavModel_KeplerianSet.keplerCusType keplerCus_; 282 public NavModel_KeplerianSet.keplerCusType getKeplerCus() { 283 return keplerCus_; 284 } 285 /** 286 * @throws ClassCastException if value is not a NavModel_KeplerianSet.keplerCusType 287 */ 288 public void setKeplerCus(Asn1Object value) { 289 this.keplerCus_ = (NavModel_KeplerianSet.keplerCusType) value; 290 } 291 public NavModel_KeplerianSet.keplerCusType setKeplerCusToNewInstance() { 292 keplerCus_ = new NavModel_KeplerianSet.keplerCusType(); 293 return keplerCus_; 294 } 295 296 private NavModel_KeplerianSet.keplerCrcType keplerCrc_; 297 public NavModel_KeplerianSet.keplerCrcType getKeplerCrc() { 298 return keplerCrc_; 299 } 300 /** 301 * @throws ClassCastException if value is not a NavModel_KeplerianSet.keplerCrcType 302 */ 303 public void setKeplerCrc(Asn1Object value) { 304 this.keplerCrc_ = (NavModel_KeplerianSet.keplerCrcType) value; 305 } 306 public NavModel_KeplerianSet.keplerCrcType setKeplerCrcToNewInstance() { 307 keplerCrc_ = new NavModel_KeplerianSet.keplerCrcType(); 308 return keplerCrc_; 309 } 310 311 private NavModel_KeplerianSet.keplerCicType keplerCic_; 312 public NavModel_KeplerianSet.keplerCicType getKeplerCic() { 313 return keplerCic_; 314 } 315 /** 316 * @throws ClassCastException if value is not a NavModel_KeplerianSet.keplerCicType 317 */ 318 public void setKeplerCic(Asn1Object value) { 319 this.keplerCic_ = (NavModel_KeplerianSet.keplerCicType) value; 320 } 321 public NavModel_KeplerianSet.keplerCicType setKeplerCicToNewInstance() { 322 keplerCic_ = new NavModel_KeplerianSet.keplerCicType(); 323 return keplerCic_; 324 } 325 326 private NavModel_KeplerianSet.keplerCucType keplerCuc_; 327 public NavModel_KeplerianSet.keplerCucType getKeplerCuc() { 328 return keplerCuc_; 329 } 330 /** 331 * @throws ClassCastException if value is not a NavModel_KeplerianSet.keplerCucType 332 */ 333 public void setKeplerCuc(Asn1Object value) { 334 this.keplerCuc_ = (NavModel_KeplerianSet.keplerCucType) value; 335 } 336 public NavModel_KeplerianSet.keplerCucType setKeplerCucToNewInstance() { 337 keplerCuc_ = new NavModel_KeplerianSet.keplerCucType(); 338 return keplerCuc_; 339 } 340 341 342 343 344 345 346 @Override public Iterable<? extends SequenceComponent> getComponents() { 347 ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder(); 348 349 builder.add(new SequenceComponent() { 350 Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0); 351 352 @Override public boolean isExplicitlySet() { 353 return getKeplerToe() != null; 354 } 355 356 @Override public boolean hasDefaultValue() { 357 return false; 358 } 359 360 @Override public boolean isOptional() { 361 return false; 362 } 363 364 @Override public Asn1Object getComponentValue() { 365 return getKeplerToe(); 366 } 367 368 @Override public void setToNewInstance() { 369 setKeplerToeToNewInstance(); 370 } 371 372 @Override public Collection<Asn1Tag> getPossibleFirstTags() { 373 return tag == null ? NavModel_KeplerianSet.keplerToeType.getPossibleFirstTags() : ImmutableList.of(tag); 374 } 375 376 @Override 377 public Asn1Tag getTag() { 378 return tag; 379 } 380 381 @Override 382 public boolean isImplicitTagging() { 383 return true; 384 } 385 386 @Override public String toIndentedString(String indent) { 387 return "keplerToe : " 388 + getKeplerToe().toIndentedString(indent); 389 } 390 }); 391 392 builder.add(new SequenceComponent() { 393 Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1); 394 395 @Override public boolean isExplicitlySet() { 396 return getKeplerW() != null; 397 } 398 399 @Override public boolean hasDefaultValue() { 400 return false; 401 } 402 403 @Override public boolean isOptional() { 404 return false; 405 } 406 407 @Override public Asn1Object getComponentValue() { 408 return getKeplerW(); 409 } 410 411 @Override public void setToNewInstance() { 412 setKeplerWToNewInstance(); 413 } 414 415 @Override public Collection<Asn1Tag> getPossibleFirstTags() { 416 return tag == null ? NavModel_KeplerianSet.keplerWType.getPossibleFirstTags() : ImmutableList.of(tag); 417 } 418 419 @Override 420 public Asn1Tag getTag() { 421 return tag; 422 } 423 424 @Override 425 public boolean isImplicitTagging() { 426 return true; 427 } 428 429 @Override public String toIndentedString(String indent) { 430 return "keplerW : " 431 + getKeplerW().toIndentedString(indent); 432 } 433 }); 434 435 builder.add(new SequenceComponent() { 436 Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2); 437 438 @Override public boolean isExplicitlySet() { 439 return getKeplerDeltaN() != null; 440 } 441 442 @Override public boolean hasDefaultValue() { 443 return false; 444 } 445 446 @Override public boolean isOptional() { 447 return false; 448 } 449 450 @Override public Asn1Object getComponentValue() { 451 return getKeplerDeltaN(); 452 } 453 454 @Override public void setToNewInstance() { 455 setKeplerDeltaNToNewInstance(); 456 } 457 458 @Override public Collection<Asn1Tag> getPossibleFirstTags() { 459 return tag == null ? NavModel_KeplerianSet.keplerDeltaNType.getPossibleFirstTags() : ImmutableList.of(tag); 460 } 461 462 @Override 463 public Asn1Tag getTag() { 464 return tag; 465 } 466 467 @Override 468 public boolean isImplicitTagging() { 469 return true; 470 } 471 472 @Override public String toIndentedString(String indent) { 473 return "keplerDeltaN : " 474 + getKeplerDeltaN().toIndentedString(indent); 475 } 476 }); 477 478 builder.add(new SequenceComponent() { 479 Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3); 480 481 @Override public boolean isExplicitlySet() { 482 return getKeplerM0() != null; 483 } 484 485 @Override public boolean hasDefaultValue() { 486 return false; 487 } 488 489 @Override public boolean isOptional() { 490 return false; 491 } 492 493 @Override public Asn1Object getComponentValue() { 494 return getKeplerM0(); 495 } 496 497 @Override public void setToNewInstance() { 498 setKeplerM0ToNewInstance(); 499 } 500 501 @Override public Collection<Asn1Tag> getPossibleFirstTags() { 502 return tag == null ? NavModel_KeplerianSet.keplerM0Type.getPossibleFirstTags() : ImmutableList.of(tag); 503 } 504 505 @Override 506 public Asn1Tag getTag() { 507 return tag; 508 } 509 510 @Override 511 public boolean isImplicitTagging() { 512 return true; 513 } 514 515 @Override public String toIndentedString(String indent) { 516 return "keplerM0 : " 517 + getKeplerM0().toIndentedString(indent); 518 } 519 }); 520 521 builder.add(new SequenceComponent() { 522 Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4); 523 524 @Override public boolean isExplicitlySet() { 525 return getKeplerOmegaDot() != null; 526 } 527 528 @Override public boolean hasDefaultValue() { 529 return false; 530 } 531 532 @Override public boolean isOptional() { 533 return false; 534 } 535 536 @Override public Asn1Object getComponentValue() { 537 return getKeplerOmegaDot(); 538 } 539 540 @Override public void setToNewInstance() { 541 setKeplerOmegaDotToNewInstance(); 542 } 543 544 @Override public Collection<Asn1Tag> getPossibleFirstTags() { 545 return tag == null ? NavModel_KeplerianSet.keplerOmegaDotType.getPossibleFirstTags() : ImmutableList.of(tag); 546 } 547 548 @Override 549 public Asn1Tag getTag() { 550 return tag; 551 } 552 553 @Override 554 public boolean isImplicitTagging() { 555 return true; 556 } 557 558 @Override public String toIndentedString(String indent) { 559 return "keplerOmegaDot : " 560 + getKeplerOmegaDot().toIndentedString(indent); 561 } 562 }); 563 564 builder.add(new SequenceComponent() { 565 Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 5); 566 567 @Override public boolean isExplicitlySet() { 568 return getKeplerE() != null; 569 } 570 571 @Override public boolean hasDefaultValue() { 572 return false; 573 } 574 575 @Override public boolean isOptional() { 576 return false; 577 } 578 579 @Override public Asn1Object getComponentValue() { 580 return getKeplerE(); 581 } 582 583 @Override public void setToNewInstance() { 584 setKeplerEToNewInstance(); 585 } 586 587 @Override public Collection<Asn1Tag> getPossibleFirstTags() { 588 return tag == null ? NavModel_KeplerianSet.keplerEType.getPossibleFirstTags() : ImmutableList.of(tag); 589 } 590 591 @Override 592 public Asn1Tag getTag() { 593 return tag; 594 } 595 596 @Override 597 public boolean isImplicitTagging() { 598 return true; 599 } 600 601 @Override public String toIndentedString(String indent) { 602 return "keplerE : " 603 + getKeplerE().toIndentedString(indent); 604 } 605 }); 606 607 builder.add(new SequenceComponent() { 608 Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 6); 609 610 @Override public boolean isExplicitlySet() { 611 return getKeplerIDot() != null; 612 } 613 614 @Override public boolean hasDefaultValue() { 615 return false; 616 } 617 618 @Override public boolean isOptional() { 619 return false; 620 } 621 622 @Override public Asn1Object getComponentValue() { 623 return getKeplerIDot(); 624 } 625 626 @Override public void setToNewInstance() { 627 setKeplerIDotToNewInstance(); 628 } 629 630 @Override public Collection<Asn1Tag> getPossibleFirstTags() { 631 return tag == null ? NavModel_KeplerianSet.keplerIDotType.getPossibleFirstTags() : ImmutableList.of(tag); 632 } 633 634 @Override 635 public Asn1Tag getTag() { 636 return tag; 637 } 638 639 @Override 640 public boolean isImplicitTagging() { 641 return true; 642 } 643 644 @Override public String toIndentedString(String indent) { 645 return "keplerIDot : " 646 + getKeplerIDot().toIndentedString(indent); 647 } 648 }); 649 650 builder.add(new SequenceComponent() { 651 Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 7); 652 653 @Override public boolean isExplicitlySet() { 654 return getKeplerAPowerHalf() != null; 655 } 656 657 @Override public boolean hasDefaultValue() { 658 return false; 659 } 660 661 @Override public boolean isOptional() { 662 return false; 663 } 664 665 @Override public Asn1Object getComponentValue() { 666 return getKeplerAPowerHalf(); 667 } 668 669 @Override public void setToNewInstance() { 670 setKeplerAPowerHalfToNewInstance(); 671 } 672 673 @Override public Collection<Asn1Tag> getPossibleFirstTags() { 674 return tag == null ? NavModel_KeplerianSet.keplerAPowerHalfType.getPossibleFirstTags() : ImmutableList.of(tag); 675 } 676 677 @Override 678 public Asn1Tag getTag() { 679 return tag; 680 } 681 682 @Override 683 public boolean isImplicitTagging() { 684 return true; 685 } 686 687 @Override public String toIndentedString(String indent) { 688 return "keplerAPowerHalf : " 689 + getKeplerAPowerHalf().toIndentedString(indent); 690 } 691 }); 692 693 builder.add(new SequenceComponent() { 694 Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 8); 695 696 @Override public boolean isExplicitlySet() { 697 return getKeplerI0() != null; 698 } 699 700 @Override public boolean hasDefaultValue() { 701 return false; 702 } 703 704 @Override public boolean isOptional() { 705 return false; 706 } 707 708 @Override public Asn1Object getComponentValue() { 709 return getKeplerI0(); 710 } 711 712 @Override public void setToNewInstance() { 713 setKeplerI0ToNewInstance(); 714 } 715 716 @Override public Collection<Asn1Tag> getPossibleFirstTags() { 717 return tag == null ? NavModel_KeplerianSet.keplerI0Type.getPossibleFirstTags() : ImmutableList.of(tag); 718 } 719 720 @Override 721 public Asn1Tag getTag() { 722 return tag; 723 } 724 725 @Override 726 public boolean isImplicitTagging() { 727 return true; 728 } 729 730 @Override public String toIndentedString(String indent) { 731 return "keplerI0 : " 732 + getKeplerI0().toIndentedString(indent); 733 } 734 }); 735 736 builder.add(new SequenceComponent() { 737 Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 9); 738 739 @Override public boolean isExplicitlySet() { 740 return getKeplerOmega0() != null; 741 } 742 743 @Override public boolean hasDefaultValue() { 744 return false; 745 } 746 747 @Override public boolean isOptional() { 748 return false; 749 } 750 751 @Override public Asn1Object getComponentValue() { 752 return getKeplerOmega0(); 753 } 754 755 @Override public void setToNewInstance() { 756 setKeplerOmega0ToNewInstance(); 757 } 758 759 @Override public Collection<Asn1Tag> getPossibleFirstTags() { 760 return tag == null ? NavModel_KeplerianSet.keplerOmega0Type.getPossibleFirstTags() : ImmutableList.of(tag); 761 } 762 763 @Override 764 public Asn1Tag getTag() { 765 return tag; 766 } 767 768 @Override 769 public boolean isImplicitTagging() { 770 return true; 771 } 772 773 @Override public String toIndentedString(String indent) { 774 return "keplerOmega0 : " 775 + getKeplerOmega0().toIndentedString(indent); 776 } 777 }); 778 779 builder.add(new SequenceComponent() { 780 Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 10); 781 782 @Override public boolean isExplicitlySet() { 783 return getKeplerCrs() != null; 784 } 785 786 @Override public boolean hasDefaultValue() { 787 return false; 788 } 789 790 @Override public boolean isOptional() { 791 return false; 792 } 793 794 @Override public Asn1Object getComponentValue() { 795 return getKeplerCrs(); 796 } 797 798 @Override public void setToNewInstance() { 799 setKeplerCrsToNewInstance(); 800 } 801 802 @Override public Collection<Asn1Tag> getPossibleFirstTags() { 803 return tag == null ? NavModel_KeplerianSet.keplerCrsType.getPossibleFirstTags() : ImmutableList.of(tag); 804 } 805 806 @Override 807 public Asn1Tag getTag() { 808 return tag; 809 } 810 811 @Override 812 public boolean isImplicitTagging() { 813 return true; 814 } 815 816 @Override public String toIndentedString(String indent) { 817 return "keplerCrs : " 818 + getKeplerCrs().toIndentedString(indent); 819 } 820 }); 821 822 builder.add(new SequenceComponent() { 823 Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 11); 824 825 @Override public boolean isExplicitlySet() { 826 return getKeplerCis() != null; 827 } 828 829 @Override public boolean hasDefaultValue() { 830 return false; 831 } 832 833 @Override public boolean isOptional() { 834 return false; 835 } 836 837 @Override public Asn1Object getComponentValue() { 838 return getKeplerCis(); 839 } 840 841 @Override public void setToNewInstance() { 842 setKeplerCisToNewInstance(); 843 } 844 845 @Override public Collection<Asn1Tag> getPossibleFirstTags() { 846 return tag == null ? NavModel_KeplerianSet.keplerCisType.getPossibleFirstTags() : ImmutableList.of(tag); 847 } 848 849 @Override 850 public Asn1Tag getTag() { 851 return tag; 852 } 853 854 @Override 855 public boolean isImplicitTagging() { 856 return true; 857 } 858 859 @Override public String toIndentedString(String indent) { 860 return "keplerCis : " 861 + getKeplerCis().toIndentedString(indent); 862 } 863 }); 864 865 builder.add(new SequenceComponent() { 866 Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 12); 867 868 @Override public boolean isExplicitlySet() { 869 return getKeplerCus() != null; 870 } 871 872 @Override public boolean hasDefaultValue() { 873 return false; 874 } 875 876 @Override public boolean isOptional() { 877 return false; 878 } 879 880 @Override public Asn1Object getComponentValue() { 881 return getKeplerCus(); 882 } 883 884 @Override public void setToNewInstance() { 885 setKeplerCusToNewInstance(); 886 } 887 888 @Override public Collection<Asn1Tag> getPossibleFirstTags() { 889 return tag == null ? NavModel_KeplerianSet.keplerCusType.getPossibleFirstTags() : ImmutableList.of(tag); 890 } 891 892 @Override 893 public Asn1Tag getTag() { 894 return tag; 895 } 896 897 @Override 898 public boolean isImplicitTagging() { 899 return true; 900 } 901 902 @Override public String toIndentedString(String indent) { 903 return "keplerCus : " 904 + getKeplerCus().toIndentedString(indent); 905 } 906 }); 907 908 builder.add(new SequenceComponent() { 909 Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 13); 910 911 @Override public boolean isExplicitlySet() { 912 return getKeplerCrc() != null; 913 } 914 915 @Override public boolean hasDefaultValue() { 916 return false; 917 } 918 919 @Override public boolean isOptional() { 920 return false; 921 } 922 923 @Override public Asn1Object getComponentValue() { 924 return getKeplerCrc(); 925 } 926 927 @Override public void setToNewInstance() { 928 setKeplerCrcToNewInstance(); 929 } 930 931 @Override public Collection<Asn1Tag> getPossibleFirstTags() { 932 return tag == null ? NavModel_KeplerianSet.keplerCrcType.getPossibleFirstTags() : ImmutableList.of(tag); 933 } 934 935 @Override 936 public Asn1Tag getTag() { 937 return tag; 938 } 939 940 @Override 941 public boolean isImplicitTagging() { 942 return true; 943 } 944 945 @Override public String toIndentedString(String indent) { 946 return "keplerCrc : " 947 + getKeplerCrc().toIndentedString(indent); 948 } 949 }); 950 951 builder.add(new SequenceComponent() { 952 Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 14); 953 954 @Override public boolean isExplicitlySet() { 955 return getKeplerCic() != null; 956 } 957 958 @Override public boolean hasDefaultValue() { 959 return false; 960 } 961 962 @Override public boolean isOptional() { 963 return false; 964 } 965 966 @Override public Asn1Object getComponentValue() { 967 return getKeplerCic(); 968 } 969 970 @Override public void setToNewInstance() { 971 setKeplerCicToNewInstance(); 972 } 973 974 @Override public Collection<Asn1Tag> getPossibleFirstTags() { 975 return tag == null ? NavModel_KeplerianSet.keplerCicType.getPossibleFirstTags() : ImmutableList.of(tag); 976 } 977 978 @Override 979 public Asn1Tag getTag() { 980 return tag; 981 } 982 983 @Override 984 public boolean isImplicitTagging() { 985 return true; 986 } 987 988 @Override public String toIndentedString(String indent) { 989 return "keplerCic : " 990 + getKeplerCic().toIndentedString(indent); 991 } 992 }); 993 994 builder.add(new SequenceComponent() { 995 Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 15); 996 997 @Override public boolean isExplicitlySet() { 998 return getKeplerCuc() != null; 999 } 1000 1001 @Override public boolean hasDefaultValue() { 1002 return false; 1003 } 1004 1005 @Override public boolean isOptional() { 1006 return false; 1007 } 1008 1009 @Override public Asn1Object getComponentValue() { 1010 return getKeplerCuc(); 1011 } 1012 1013 @Override public void setToNewInstance() { 1014 setKeplerCucToNewInstance(); 1015 } 1016 1017 @Override public Collection<Asn1Tag> getPossibleFirstTags() { 1018 return tag == null ? NavModel_KeplerianSet.keplerCucType.getPossibleFirstTags() : ImmutableList.of(tag); 1019 } 1020 1021 @Override 1022 public Asn1Tag getTag() { 1023 return tag; 1024 } 1025 1026 @Override 1027 public boolean isImplicitTagging() { 1028 return true; 1029 } 1030 1031 @Override public String toIndentedString(String indent) { 1032 return "keplerCuc : " 1033 + getKeplerCuc().toIndentedString(indent); 1034 } 1035 }); 1036 1037 return builder.build(); 1038 } 1039 1040 @Override public Iterable<? extends SequenceComponent> 1041 getExtensionComponents() { 1042 ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder(); 1043 1044 return builder.build(); 1045 } 1046 1047 1048 /* 1049 */ 1050 1051 1052 // 1053 1054 /** 1055 */ 1056 public static class keplerToeType extends Asn1Integer { 1057 // 1058 1059 private static final Asn1Tag TAG_keplerToeType 1060 = Asn1Tag.fromClassAndNumber(-1, -1); 1061 1062 public keplerToeType() { 1063 super(); 1064 setValueRange("0", "16383"); 1065 1066 } 1067 1068 @Override 1069 @Nullable 1070 protected Asn1Tag getTag() { 1071 return TAG_keplerToeType; 1072 } 1073 1074 @Override 1075 protected boolean isTagImplicit() { 1076 return true; 1077 } 1078 1079 public static Collection<Asn1Tag> getPossibleFirstTags() { 1080 if (TAG_keplerToeType != null) { 1081 return ImmutableList.of(TAG_keplerToeType); 1082 } else { 1083 return Asn1Integer.getPossibleFirstTags(); 1084 } 1085 } 1086 1087 /** 1088 * Creates a new keplerToeType from encoded stream. 1089 */ 1090 public static keplerToeType fromPerUnaligned(byte[] encodedBytes) { 1091 keplerToeType result = new keplerToeType(); 1092 result.decodePerUnaligned(new BitStreamReader(encodedBytes)); 1093 return result; 1094 } 1095 1096 /** 1097 * Creates a new keplerToeType from encoded stream. 1098 */ 1099 public static keplerToeType fromPerAligned(byte[] encodedBytes) { 1100 keplerToeType result = new keplerToeType(); 1101 result.decodePerAligned(new BitStreamReader(encodedBytes)); 1102 return result; 1103 } 1104 1105 @Override public Iterable<BitStream> encodePerUnaligned() { 1106 return super.encodePerUnaligned(); 1107 } 1108 1109 @Override public Iterable<BitStream> encodePerAligned() { 1110 return super.encodePerAligned(); 1111 } 1112 1113 @Override public void decodePerUnaligned(BitStreamReader reader) { 1114 super.decodePerUnaligned(reader); 1115 } 1116 1117 @Override public void decodePerAligned(BitStreamReader reader) { 1118 super.decodePerAligned(reader); 1119 } 1120 1121 @Override public String toString() { 1122 return toIndentedString(""); 1123 } 1124 1125 public String toIndentedString(String indent) { 1126 return "keplerToeType = " + getInteger() + ";\n"; 1127 } 1128 } 1129 1130 1131 /* 1132 */ 1133 1134 1135 // 1136 1137 /** 1138 */ 1139 public static class keplerWType extends Asn1Integer { 1140 // 1141 1142 private static final Asn1Tag TAG_keplerWType 1143 = Asn1Tag.fromClassAndNumber(-1, -1); 1144 1145 public keplerWType() { 1146 super(); 1147 setValueRange("-2147483648", "2147483647"); 1148 1149 } 1150 1151 @Override 1152 @Nullable 1153 protected Asn1Tag getTag() { 1154 return TAG_keplerWType; 1155 } 1156 1157 @Override 1158 protected boolean isTagImplicit() { 1159 return true; 1160 } 1161 1162 public static Collection<Asn1Tag> getPossibleFirstTags() { 1163 if (TAG_keplerWType != null) { 1164 return ImmutableList.of(TAG_keplerWType); 1165 } else { 1166 return Asn1Integer.getPossibleFirstTags(); 1167 } 1168 } 1169 1170 /** 1171 * Creates a new keplerWType from encoded stream. 1172 */ 1173 public static keplerWType fromPerUnaligned(byte[] encodedBytes) { 1174 keplerWType result = new keplerWType(); 1175 result.decodePerUnaligned(new BitStreamReader(encodedBytes)); 1176 return result; 1177 } 1178 1179 /** 1180 * Creates a new keplerWType from encoded stream. 1181 */ 1182 public static keplerWType fromPerAligned(byte[] encodedBytes) { 1183 keplerWType result = new keplerWType(); 1184 result.decodePerAligned(new BitStreamReader(encodedBytes)); 1185 return result; 1186 } 1187 1188 @Override public Iterable<BitStream> encodePerUnaligned() { 1189 return super.encodePerUnaligned(); 1190 } 1191 1192 @Override public Iterable<BitStream> encodePerAligned() { 1193 return super.encodePerAligned(); 1194 } 1195 1196 @Override public void decodePerUnaligned(BitStreamReader reader) { 1197 super.decodePerUnaligned(reader); 1198 } 1199 1200 @Override public void decodePerAligned(BitStreamReader reader) { 1201 super.decodePerAligned(reader); 1202 } 1203 1204 @Override public String toString() { 1205 return toIndentedString(""); 1206 } 1207 1208 public String toIndentedString(String indent) { 1209 return "keplerWType = " + getInteger() + ";\n"; 1210 } 1211 } 1212 1213 1214 /* 1215 */ 1216 1217 1218 // 1219 1220 /** 1221 */ 1222 public static class keplerDeltaNType extends Asn1Integer { 1223 // 1224 1225 private static final Asn1Tag TAG_keplerDeltaNType 1226 = Asn1Tag.fromClassAndNumber(-1, -1); 1227 1228 public keplerDeltaNType() { 1229 super(); 1230 setValueRange("-32768", "32767"); 1231 1232 } 1233 1234 @Override 1235 @Nullable 1236 protected Asn1Tag getTag() { 1237 return TAG_keplerDeltaNType; 1238 } 1239 1240 @Override 1241 protected boolean isTagImplicit() { 1242 return true; 1243 } 1244 1245 public static Collection<Asn1Tag> getPossibleFirstTags() { 1246 if (TAG_keplerDeltaNType != null) { 1247 return ImmutableList.of(TAG_keplerDeltaNType); 1248 } else { 1249 return Asn1Integer.getPossibleFirstTags(); 1250 } 1251 } 1252 1253 /** 1254 * Creates a new keplerDeltaNType from encoded stream. 1255 */ 1256 public static keplerDeltaNType fromPerUnaligned(byte[] encodedBytes) { 1257 keplerDeltaNType result = new keplerDeltaNType(); 1258 result.decodePerUnaligned(new BitStreamReader(encodedBytes)); 1259 return result; 1260 } 1261 1262 /** 1263 * Creates a new keplerDeltaNType from encoded stream. 1264 */ 1265 public static keplerDeltaNType fromPerAligned(byte[] encodedBytes) { 1266 keplerDeltaNType result = new keplerDeltaNType(); 1267 result.decodePerAligned(new BitStreamReader(encodedBytes)); 1268 return result; 1269 } 1270 1271 @Override public Iterable<BitStream> encodePerUnaligned() { 1272 return super.encodePerUnaligned(); 1273 } 1274 1275 @Override public Iterable<BitStream> encodePerAligned() { 1276 return super.encodePerAligned(); 1277 } 1278 1279 @Override public void decodePerUnaligned(BitStreamReader reader) { 1280 super.decodePerUnaligned(reader); 1281 } 1282 1283 @Override public void decodePerAligned(BitStreamReader reader) { 1284 super.decodePerAligned(reader); 1285 } 1286 1287 @Override public String toString() { 1288 return toIndentedString(""); 1289 } 1290 1291 public String toIndentedString(String indent) { 1292 return "keplerDeltaNType = " + getInteger() + ";\n"; 1293 } 1294 } 1295 1296 1297 /* 1298 */ 1299 1300 1301 // 1302 1303 /** 1304 */ 1305 public static class keplerM0Type extends Asn1Integer { 1306 // 1307 1308 private static final Asn1Tag TAG_keplerM0Type 1309 = Asn1Tag.fromClassAndNumber(-1, -1); 1310 1311 public keplerM0Type() { 1312 super(); 1313 setValueRange("-2147483648", "2147483647"); 1314 1315 } 1316 1317 @Override 1318 @Nullable 1319 protected Asn1Tag getTag() { 1320 return TAG_keplerM0Type; 1321 } 1322 1323 @Override 1324 protected boolean isTagImplicit() { 1325 return true; 1326 } 1327 1328 public static Collection<Asn1Tag> getPossibleFirstTags() { 1329 if (TAG_keplerM0Type != null) { 1330 return ImmutableList.of(TAG_keplerM0Type); 1331 } else { 1332 return Asn1Integer.getPossibleFirstTags(); 1333 } 1334 } 1335 1336 /** 1337 * Creates a new keplerM0Type from encoded stream. 1338 */ 1339 public static keplerM0Type fromPerUnaligned(byte[] encodedBytes) { 1340 keplerM0Type result = new keplerM0Type(); 1341 result.decodePerUnaligned(new BitStreamReader(encodedBytes)); 1342 return result; 1343 } 1344 1345 /** 1346 * Creates a new keplerM0Type from encoded stream. 1347 */ 1348 public static keplerM0Type fromPerAligned(byte[] encodedBytes) { 1349 keplerM0Type result = new keplerM0Type(); 1350 result.decodePerAligned(new BitStreamReader(encodedBytes)); 1351 return result; 1352 } 1353 1354 @Override public Iterable<BitStream> encodePerUnaligned() { 1355 return super.encodePerUnaligned(); 1356 } 1357 1358 @Override public Iterable<BitStream> encodePerAligned() { 1359 return super.encodePerAligned(); 1360 } 1361 1362 @Override public void decodePerUnaligned(BitStreamReader reader) { 1363 super.decodePerUnaligned(reader); 1364 } 1365 1366 @Override public void decodePerAligned(BitStreamReader reader) { 1367 super.decodePerAligned(reader); 1368 } 1369 1370 @Override public String toString() { 1371 return toIndentedString(""); 1372 } 1373 1374 public String toIndentedString(String indent) { 1375 return "keplerM0Type = " + getInteger() + ";\n"; 1376 } 1377 } 1378 1379 1380 /* 1381 */ 1382 1383 1384 // 1385 1386 /** 1387 */ 1388 public static class keplerOmegaDotType extends Asn1Integer { 1389 // 1390 1391 private static final Asn1Tag TAG_keplerOmegaDotType 1392 = Asn1Tag.fromClassAndNumber(-1, -1); 1393 1394 public keplerOmegaDotType() { 1395 super(); 1396 setValueRange("-8388608", "8388607"); 1397 1398 } 1399 1400 @Override 1401 @Nullable 1402 protected Asn1Tag getTag() { 1403 return TAG_keplerOmegaDotType; 1404 } 1405 1406 @Override 1407 protected boolean isTagImplicit() { 1408 return true; 1409 } 1410 1411 public static Collection<Asn1Tag> getPossibleFirstTags() { 1412 if (TAG_keplerOmegaDotType != null) { 1413 return ImmutableList.of(TAG_keplerOmegaDotType); 1414 } else { 1415 return Asn1Integer.getPossibleFirstTags(); 1416 } 1417 } 1418 1419 /** 1420 * Creates a new keplerOmegaDotType from encoded stream. 1421 */ 1422 public static keplerOmegaDotType fromPerUnaligned(byte[] encodedBytes) { 1423 keplerOmegaDotType result = new keplerOmegaDotType(); 1424 result.decodePerUnaligned(new BitStreamReader(encodedBytes)); 1425 return result; 1426 } 1427 1428 /** 1429 * Creates a new keplerOmegaDotType from encoded stream. 1430 */ 1431 public static keplerOmegaDotType fromPerAligned(byte[] encodedBytes) { 1432 keplerOmegaDotType result = new keplerOmegaDotType(); 1433 result.decodePerAligned(new BitStreamReader(encodedBytes)); 1434 return result; 1435 } 1436 1437 @Override public Iterable<BitStream> encodePerUnaligned() { 1438 return super.encodePerUnaligned(); 1439 } 1440 1441 @Override public Iterable<BitStream> encodePerAligned() { 1442 return super.encodePerAligned(); 1443 } 1444 1445 @Override public void decodePerUnaligned(BitStreamReader reader) { 1446 super.decodePerUnaligned(reader); 1447 } 1448 1449 @Override public void decodePerAligned(BitStreamReader reader) { 1450 super.decodePerAligned(reader); 1451 } 1452 1453 @Override public String toString() { 1454 return toIndentedString(""); 1455 } 1456 1457 public String toIndentedString(String indent) { 1458 return "keplerOmegaDotType = " + getInteger() + ";\n"; 1459 } 1460 } 1461 1462 1463 /* 1464 */ 1465 1466 1467 // 1468 1469 /** 1470 */ 1471 public static class keplerEType extends Asn1Integer { 1472 // 1473 1474 private static final Asn1Tag TAG_keplerEType 1475 = Asn1Tag.fromClassAndNumber(-1, -1); 1476 1477 public keplerEType() { 1478 super(); 1479 setValueRange("0", "4294967295"); 1480 1481 } 1482 1483 @Override 1484 @Nullable 1485 protected Asn1Tag getTag() { 1486 return TAG_keplerEType; 1487 } 1488 1489 @Override 1490 protected boolean isTagImplicit() { 1491 return true; 1492 } 1493 1494 public static Collection<Asn1Tag> getPossibleFirstTags() { 1495 if (TAG_keplerEType != null) { 1496 return ImmutableList.of(TAG_keplerEType); 1497 } else { 1498 return Asn1Integer.getPossibleFirstTags(); 1499 } 1500 } 1501 1502 /** 1503 * Creates a new keplerEType from encoded stream. 1504 */ 1505 public static keplerEType fromPerUnaligned(byte[] encodedBytes) { 1506 keplerEType result = new keplerEType(); 1507 result.decodePerUnaligned(new BitStreamReader(encodedBytes)); 1508 return result; 1509 } 1510 1511 /** 1512 * Creates a new keplerEType from encoded stream. 1513 */ 1514 public static keplerEType fromPerAligned(byte[] encodedBytes) { 1515 keplerEType result = new keplerEType(); 1516 result.decodePerAligned(new BitStreamReader(encodedBytes)); 1517 return result; 1518 } 1519 1520 @Override public Iterable<BitStream> encodePerUnaligned() { 1521 return super.encodePerUnaligned(); 1522 } 1523 1524 @Override public Iterable<BitStream> encodePerAligned() { 1525 return super.encodePerAligned(); 1526 } 1527 1528 @Override public void decodePerUnaligned(BitStreamReader reader) { 1529 super.decodePerUnaligned(reader); 1530 } 1531 1532 @Override public void decodePerAligned(BitStreamReader reader) { 1533 super.decodePerAligned(reader); 1534 } 1535 1536 @Override public String toString() { 1537 return toIndentedString(""); 1538 } 1539 1540 public String toIndentedString(String indent) { 1541 return "keplerEType = " + getInteger() + ";\n"; 1542 } 1543 } 1544 1545 1546 /* 1547 */ 1548 1549 1550 // 1551 1552 /** 1553 */ 1554 public static class keplerIDotType extends Asn1Integer { 1555 // 1556 1557 private static final Asn1Tag TAG_keplerIDotType 1558 = Asn1Tag.fromClassAndNumber(-1, -1); 1559 1560 public keplerIDotType() { 1561 super(); 1562 setValueRange("-8192", "8191"); 1563 1564 } 1565 1566 @Override 1567 @Nullable 1568 protected Asn1Tag getTag() { 1569 return TAG_keplerIDotType; 1570 } 1571 1572 @Override 1573 protected boolean isTagImplicit() { 1574 return true; 1575 } 1576 1577 public static Collection<Asn1Tag> getPossibleFirstTags() { 1578 if (TAG_keplerIDotType != null) { 1579 return ImmutableList.of(TAG_keplerIDotType); 1580 } else { 1581 return Asn1Integer.getPossibleFirstTags(); 1582 } 1583 } 1584 1585 /** 1586 * Creates a new keplerIDotType from encoded stream. 1587 */ 1588 public static keplerIDotType fromPerUnaligned(byte[] encodedBytes) { 1589 keplerIDotType result = new keplerIDotType(); 1590 result.decodePerUnaligned(new BitStreamReader(encodedBytes)); 1591 return result; 1592 } 1593 1594 /** 1595 * Creates a new keplerIDotType from encoded stream. 1596 */ 1597 public static keplerIDotType fromPerAligned(byte[] encodedBytes) { 1598 keplerIDotType result = new keplerIDotType(); 1599 result.decodePerAligned(new BitStreamReader(encodedBytes)); 1600 return result; 1601 } 1602 1603 @Override public Iterable<BitStream> encodePerUnaligned() { 1604 return super.encodePerUnaligned(); 1605 } 1606 1607 @Override public Iterable<BitStream> encodePerAligned() { 1608 return super.encodePerAligned(); 1609 } 1610 1611 @Override public void decodePerUnaligned(BitStreamReader reader) { 1612 super.decodePerUnaligned(reader); 1613 } 1614 1615 @Override public void decodePerAligned(BitStreamReader reader) { 1616 super.decodePerAligned(reader); 1617 } 1618 1619 @Override public String toString() { 1620 return toIndentedString(""); 1621 } 1622 1623 public String toIndentedString(String indent) { 1624 return "keplerIDotType = " + getInteger() + ";\n"; 1625 } 1626 } 1627 1628 1629 /* 1630 */ 1631 1632 1633 // 1634 1635 /** 1636 */ 1637 public static class keplerAPowerHalfType extends Asn1Integer { 1638 // 1639 1640 private static final Asn1Tag TAG_keplerAPowerHalfType 1641 = Asn1Tag.fromClassAndNumber(-1, -1); 1642 1643 public keplerAPowerHalfType() { 1644 super(); 1645 setValueRange("0", "4294967295"); 1646 1647 } 1648 1649 @Override 1650 @Nullable 1651 protected Asn1Tag getTag() { 1652 return TAG_keplerAPowerHalfType; 1653 } 1654 1655 @Override 1656 protected boolean isTagImplicit() { 1657 return true; 1658 } 1659 1660 public static Collection<Asn1Tag> getPossibleFirstTags() { 1661 if (TAG_keplerAPowerHalfType != null) { 1662 return ImmutableList.of(TAG_keplerAPowerHalfType); 1663 } else { 1664 return Asn1Integer.getPossibleFirstTags(); 1665 } 1666 } 1667 1668 /** 1669 * Creates a new keplerAPowerHalfType from encoded stream. 1670 */ 1671 public static keplerAPowerHalfType fromPerUnaligned(byte[] encodedBytes) { 1672 keplerAPowerHalfType result = new keplerAPowerHalfType(); 1673 result.decodePerUnaligned(new BitStreamReader(encodedBytes)); 1674 return result; 1675 } 1676 1677 /** 1678 * Creates a new keplerAPowerHalfType from encoded stream. 1679 */ 1680 public static keplerAPowerHalfType fromPerAligned(byte[] encodedBytes) { 1681 keplerAPowerHalfType result = new keplerAPowerHalfType(); 1682 result.decodePerAligned(new BitStreamReader(encodedBytes)); 1683 return result; 1684 } 1685 1686 @Override public Iterable<BitStream> encodePerUnaligned() { 1687 return super.encodePerUnaligned(); 1688 } 1689 1690 @Override public Iterable<BitStream> encodePerAligned() { 1691 return super.encodePerAligned(); 1692 } 1693 1694 @Override public void decodePerUnaligned(BitStreamReader reader) { 1695 super.decodePerUnaligned(reader); 1696 } 1697 1698 @Override public void decodePerAligned(BitStreamReader reader) { 1699 super.decodePerAligned(reader); 1700 } 1701 1702 @Override public String toString() { 1703 return toIndentedString(""); 1704 } 1705 1706 public String toIndentedString(String indent) { 1707 return "keplerAPowerHalfType = " + getInteger() + ";\n"; 1708 } 1709 } 1710 1711 1712 /* 1713 */ 1714 1715 1716 // 1717 1718 /** 1719 */ 1720 public static class keplerI0Type extends Asn1Integer { 1721 // 1722 1723 private static final Asn1Tag TAG_keplerI0Type 1724 = Asn1Tag.fromClassAndNumber(-1, -1); 1725 1726 public keplerI0Type() { 1727 super(); 1728 setValueRange("-2147483648", "2147483647"); 1729 1730 } 1731 1732 @Override 1733 @Nullable 1734 protected Asn1Tag getTag() { 1735 return TAG_keplerI0Type; 1736 } 1737 1738 @Override 1739 protected boolean isTagImplicit() { 1740 return true; 1741 } 1742 1743 public static Collection<Asn1Tag> getPossibleFirstTags() { 1744 if (TAG_keplerI0Type != null) { 1745 return ImmutableList.of(TAG_keplerI0Type); 1746 } else { 1747 return Asn1Integer.getPossibleFirstTags(); 1748 } 1749 } 1750 1751 /** 1752 * Creates a new keplerI0Type from encoded stream. 1753 */ 1754 public static keplerI0Type fromPerUnaligned(byte[] encodedBytes) { 1755 keplerI0Type result = new keplerI0Type(); 1756 result.decodePerUnaligned(new BitStreamReader(encodedBytes)); 1757 return result; 1758 } 1759 1760 /** 1761 * Creates a new keplerI0Type from encoded stream. 1762 */ 1763 public static keplerI0Type fromPerAligned(byte[] encodedBytes) { 1764 keplerI0Type result = new keplerI0Type(); 1765 result.decodePerAligned(new BitStreamReader(encodedBytes)); 1766 return result; 1767 } 1768 1769 @Override public Iterable<BitStream> encodePerUnaligned() { 1770 return super.encodePerUnaligned(); 1771 } 1772 1773 @Override public Iterable<BitStream> encodePerAligned() { 1774 return super.encodePerAligned(); 1775 } 1776 1777 @Override public void decodePerUnaligned(BitStreamReader reader) { 1778 super.decodePerUnaligned(reader); 1779 } 1780 1781 @Override public void decodePerAligned(BitStreamReader reader) { 1782 super.decodePerAligned(reader); 1783 } 1784 1785 @Override public String toString() { 1786 return toIndentedString(""); 1787 } 1788 1789 public String toIndentedString(String indent) { 1790 return "keplerI0Type = " + getInteger() + ";\n"; 1791 } 1792 } 1793 1794 1795 /* 1796 */ 1797 1798 1799 // 1800 1801 /** 1802 */ 1803 public static class keplerOmega0Type extends Asn1Integer { 1804 // 1805 1806 private static final Asn1Tag TAG_keplerOmega0Type 1807 = Asn1Tag.fromClassAndNumber(-1, -1); 1808 1809 public keplerOmega0Type() { 1810 super(); 1811 setValueRange("-2147483648", "2147483647"); 1812 1813 } 1814 1815 @Override 1816 @Nullable 1817 protected Asn1Tag getTag() { 1818 return TAG_keplerOmega0Type; 1819 } 1820 1821 @Override 1822 protected boolean isTagImplicit() { 1823 return true; 1824 } 1825 1826 public static Collection<Asn1Tag> getPossibleFirstTags() { 1827 if (TAG_keplerOmega0Type != null) { 1828 return ImmutableList.of(TAG_keplerOmega0Type); 1829 } else { 1830 return Asn1Integer.getPossibleFirstTags(); 1831 } 1832 } 1833 1834 /** 1835 * Creates a new keplerOmega0Type from encoded stream. 1836 */ 1837 public static keplerOmega0Type fromPerUnaligned(byte[] encodedBytes) { 1838 keplerOmega0Type result = new keplerOmega0Type(); 1839 result.decodePerUnaligned(new BitStreamReader(encodedBytes)); 1840 return result; 1841 } 1842 1843 /** 1844 * Creates a new keplerOmega0Type from encoded stream. 1845 */ 1846 public static keplerOmega0Type fromPerAligned(byte[] encodedBytes) { 1847 keplerOmega0Type result = new keplerOmega0Type(); 1848 result.decodePerAligned(new BitStreamReader(encodedBytes)); 1849 return result; 1850 } 1851 1852 @Override public Iterable<BitStream> encodePerUnaligned() { 1853 return super.encodePerUnaligned(); 1854 } 1855 1856 @Override public Iterable<BitStream> encodePerAligned() { 1857 return super.encodePerAligned(); 1858 } 1859 1860 @Override public void decodePerUnaligned(BitStreamReader reader) { 1861 super.decodePerUnaligned(reader); 1862 } 1863 1864 @Override public void decodePerAligned(BitStreamReader reader) { 1865 super.decodePerAligned(reader); 1866 } 1867 1868 @Override public String toString() { 1869 return toIndentedString(""); 1870 } 1871 1872 public String toIndentedString(String indent) { 1873 return "keplerOmega0Type = " + getInteger() + ";\n"; 1874 } 1875 } 1876 1877 1878 /* 1879 */ 1880 1881 1882 // 1883 1884 /** 1885 */ 1886 public static class keplerCrsType extends Asn1Integer { 1887 // 1888 1889 private static final Asn1Tag TAG_keplerCrsType 1890 = Asn1Tag.fromClassAndNumber(-1, -1); 1891 1892 public keplerCrsType() { 1893 super(); 1894 setValueRange("-32768", "32767"); 1895 1896 } 1897 1898 @Override 1899 @Nullable 1900 protected Asn1Tag getTag() { 1901 return TAG_keplerCrsType; 1902 } 1903 1904 @Override 1905 protected boolean isTagImplicit() { 1906 return true; 1907 } 1908 1909 public static Collection<Asn1Tag> getPossibleFirstTags() { 1910 if (TAG_keplerCrsType != null) { 1911 return ImmutableList.of(TAG_keplerCrsType); 1912 } else { 1913 return Asn1Integer.getPossibleFirstTags(); 1914 } 1915 } 1916 1917 /** 1918 * Creates a new keplerCrsType from encoded stream. 1919 */ 1920 public static keplerCrsType fromPerUnaligned(byte[] encodedBytes) { 1921 keplerCrsType result = new keplerCrsType(); 1922 result.decodePerUnaligned(new BitStreamReader(encodedBytes)); 1923 return result; 1924 } 1925 1926 /** 1927 * Creates a new keplerCrsType from encoded stream. 1928 */ 1929 public static keplerCrsType fromPerAligned(byte[] encodedBytes) { 1930 keplerCrsType result = new keplerCrsType(); 1931 result.decodePerAligned(new BitStreamReader(encodedBytes)); 1932 return result; 1933 } 1934 1935 @Override public Iterable<BitStream> encodePerUnaligned() { 1936 return super.encodePerUnaligned(); 1937 } 1938 1939 @Override public Iterable<BitStream> encodePerAligned() { 1940 return super.encodePerAligned(); 1941 } 1942 1943 @Override public void decodePerUnaligned(BitStreamReader reader) { 1944 super.decodePerUnaligned(reader); 1945 } 1946 1947 @Override public void decodePerAligned(BitStreamReader reader) { 1948 super.decodePerAligned(reader); 1949 } 1950 1951 @Override public String toString() { 1952 return toIndentedString(""); 1953 } 1954 1955 public String toIndentedString(String indent) { 1956 return "keplerCrsType = " + getInteger() + ";\n"; 1957 } 1958 } 1959 1960 1961 /* 1962 */ 1963 1964 1965 // 1966 1967 /** 1968 */ 1969 public static class keplerCisType extends Asn1Integer { 1970 // 1971 1972 private static final Asn1Tag TAG_keplerCisType 1973 = Asn1Tag.fromClassAndNumber(-1, -1); 1974 1975 public keplerCisType() { 1976 super(); 1977 setValueRange("-32768", "32767"); 1978 1979 } 1980 1981 @Override 1982 @Nullable 1983 protected Asn1Tag getTag() { 1984 return TAG_keplerCisType; 1985 } 1986 1987 @Override 1988 protected boolean isTagImplicit() { 1989 return true; 1990 } 1991 1992 public static Collection<Asn1Tag> getPossibleFirstTags() { 1993 if (TAG_keplerCisType != null) { 1994 return ImmutableList.of(TAG_keplerCisType); 1995 } else { 1996 return Asn1Integer.getPossibleFirstTags(); 1997 } 1998 } 1999 2000 /** 2001 * Creates a new keplerCisType from encoded stream. 2002 */ 2003 public static keplerCisType fromPerUnaligned(byte[] encodedBytes) { 2004 keplerCisType result = new keplerCisType(); 2005 result.decodePerUnaligned(new BitStreamReader(encodedBytes)); 2006 return result; 2007 } 2008 2009 /** 2010 * Creates a new keplerCisType from encoded stream. 2011 */ 2012 public static keplerCisType fromPerAligned(byte[] encodedBytes) { 2013 keplerCisType result = new keplerCisType(); 2014 result.decodePerAligned(new BitStreamReader(encodedBytes)); 2015 return result; 2016 } 2017 2018 @Override public Iterable<BitStream> encodePerUnaligned() { 2019 return super.encodePerUnaligned(); 2020 } 2021 2022 @Override public Iterable<BitStream> encodePerAligned() { 2023 return super.encodePerAligned(); 2024 } 2025 2026 @Override public void decodePerUnaligned(BitStreamReader reader) { 2027 super.decodePerUnaligned(reader); 2028 } 2029 2030 @Override public void decodePerAligned(BitStreamReader reader) { 2031 super.decodePerAligned(reader); 2032 } 2033 2034 @Override public String toString() { 2035 return toIndentedString(""); 2036 } 2037 2038 public String toIndentedString(String indent) { 2039 return "keplerCisType = " + getInteger() + ";\n"; 2040 } 2041 } 2042 2043 2044 /* 2045 */ 2046 2047 2048 // 2049 2050 /** 2051 */ 2052 public static class keplerCusType extends Asn1Integer { 2053 // 2054 2055 private static final Asn1Tag TAG_keplerCusType 2056 = Asn1Tag.fromClassAndNumber(-1, -1); 2057 2058 public keplerCusType() { 2059 super(); 2060 setValueRange("-32768", "32767"); 2061 2062 } 2063 2064 @Override 2065 @Nullable 2066 protected Asn1Tag getTag() { 2067 return TAG_keplerCusType; 2068 } 2069 2070 @Override 2071 protected boolean isTagImplicit() { 2072 return true; 2073 } 2074 2075 public static Collection<Asn1Tag> getPossibleFirstTags() { 2076 if (TAG_keplerCusType != null) { 2077 return ImmutableList.of(TAG_keplerCusType); 2078 } else { 2079 return Asn1Integer.getPossibleFirstTags(); 2080 } 2081 } 2082 2083 /** 2084 * Creates a new keplerCusType from encoded stream. 2085 */ 2086 public static keplerCusType fromPerUnaligned(byte[] encodedBytes) { 2087 keplerCusType result = new keplerCusType(); 2088 result.decodePerUnaligned(new BitStreamReader(encodedBytes)); 2089 return result; 2090 } 2091 2092 /** 2093 * Creates a new keplerCusType from encoded stream. 2094 */ 2095 public static keplerCusType fromPerAligned(byte[] encodedBytes) { 2096 keplerCusType result = new keplerCusType(); 2097 result.decodePerAligned(new BitStreamReader(encodedBytes)); 2098 return result; 2099 } 2100 2101 @Override public Iterable<BitStream> encodePerUnaligned() { 2102 return super.encodePerUnaligned(); 2103 } 2104 2105 @Override public Iterable<BitStream> encodePerAligned() { 2106 return super.encodePerAligned(); 2107 } 2108 2109 @Override public void decodePerUnaligned(BitStreamReader reader) { 2110 super.decodePerUnaligned(reader); 2111 } 2112 2113 @Override public void decodePerAligned(BitStreamReader reader) { 2114 super.decodePerAligned(reader); 2115 } 2116 2117 @Override public String toString() { 2118 return toIndentedString(""); 2119 } 2120 2121 public String toIndentedString(String indent) { 2122 return "keplerCusType = " + getInteger() + ";\n"; 2123 } 2124 } 2125 2126 2127 /* 2128 */ 2129 2130 2131 // 2132 2133 /** 2134 */ 2135 public static class keplerCrcType extends Asn1Integer { 2136 // 2137 2138 private static final Asn1Tag TAG_keplerCrcType 2139 = Asn1Tag.fromClassAndNumber(-1, -1); 2140 2141 public keplerCrcType() { 2142 super(); 2143 setValueRange("-32768", "32767"); 2144 2145 } 2146 2147 @Override 2148 @Nullable 2149 protected Asn1Tag getTag() { 2150 return TAG_keplerCrcType; 2151 } 2152 2153 @Override 2154 protected boolean isTagImplicit() { 2155 return true; 2156 } 2157 2158 public static Collection<Asn1Tag> getPossibleFirstTags() { 2159 if (TAG_keplerCrcType != null) { 2160 return ImmutableList.of(TAG_keplerCrcType); 2161 } else { 2162 return Asn1Integer.getPossibleFirstTags(); 2163 } 2164 } 2165 2166 /** 2167 * Creates a new keplerCrcType from encoded stream. 2168 */ 2169 public static keplerCrcType fromPerUnaligned(byte[] encodedBytes) { 2170 keplerCrcType result = new keplerCrcType(); 2171 result.decodePerUnaligned(new BitStreamReader(encodedBytes)); 2172 return result; 2173 } 2174 2175 /** 2176 * Creates a new keplerCrcType from encoded stream. 2177 */ 2178 public static keplerCrcType fromPerAligned(byte[] encodedBytes) { 2179 keplerCrcType result = new keplerCrcType(); 2180 result.decodePerAligned(new BitStreamReader(encodedBytes)); 2181 return result; 2182 } 2183 2184 @Override public Iterable<BitStream> encodePerUnaligned() { 2185 return super.encodePerUnaligned(); 2186 } 2187 2188 @Override public Iterable<BitStream> encodePerAligned() { 2189 return super.encodePerAligned(); 2190 } 2191 2192 @Override public void decodePerUnaligned(BitStreamReader reader) { 2193 super.decodePerUnaligned(reader); 2194 } 2195 2196 @Override public void decodePerAligned(BitStreamReader reader) { 2197 super.decodePerAligned(reader); 2198 } 2199 2200 @Override public String toString() { 2201 return toIndentedString(""); 2202 } 2203 2204 public String toIndentedString(String indent) { 2205 return "keplerCrcType = " + getInteger() + ";\n"; 2206 } 2207 } 2208 2209 2210 /* 2211 */ 2212 2213 2214 // 2215 2216 /** 2217 */ 2218 public static class keplerCicType extends Asn1Integer { 2219 // 2220 2221 private static final Asn1Tag TAG_keplerCicType 2222 = Asn1Tag.fromClassAndNumber(-1, -1); 2223 2224 public keplerCicType() { 2225 super(); 2226 setValueRange("-32768", "32767"); 2227 2228 } 2229 2230 @Override 2231 @Nullable 2232 protected Asn1Tag getTag() { 2233 return TAG_keplerCicType; 2234 } 2235 2236 @Override 2237 protected boolean isTagImplicit() { 2238 return true; 2239 } 2240 2241 public static Collection<Asn1Tag> getPossibleFirstTags() { 2242 if (TAG_keplerCicType != null) { 2243 return ImmutableList.of(TAG_keplerCicType); 2244 } else { 2245 return Asn1Integer.getPossibleFirstTags(); 2246 } 2247 } 2248 2249 /** 2250 * Creates a new keplerCicType from encoded stream. 2251 */ 2252 public static keplerCicType fromPerUnaligned(byte[] encodedBytes) { 2253 keplerCicType result = new keplerCicType(); 2254 result.decodePerUnaligned(new BitStreamReader(encodedBytes)); 2255 return result; 2256 } 2257 2258 /** 2259 * Creates a new keplerCicType from encoded stream. 2260 */ 2261 public static keplerCicType fromPerAligned(byte[] encodedBytes) { 2262 keplerCicType result = new keplerCicType(); 2263 result.decodePerAligned(new BitStreamReader(encodedBytes)); 2264 return result; 2265 } 2266 2267 @Override public Iterable<BitStream> encodePerUnaligned() { 2268 return super.encodePerUnaligned(); 2269 } 2270 2271 @Override public Iterable<BitStream> encodePerAligned() { 2272 return super.encodePerAligned(); 2273 } 2274 2275 @Override public void decodePerUnaligned(BitStreamReader reader) { 2276 super.decodePerUnaligned(reader); 2277 } 2278 2279 @Override public void decodePerAligned(BitStreamReader reader) { 2280 super.decodePerAligned(reader); 2281 } 2282 2283 @Override public String toString() { 2284 return toIndentedString(""); 2285 } 2286 2287 public String toIndentedString(String indent) { 2288 return "keplerCicType = " + getInteger() + ";\n"; 2289 } 2290 } 2291 2292 2293 /* 2294 */ 2295 2296 2297 // 2298 2299 /** 2300 */ 2301 public static class keplerCucType extends Asn1Integer { 2302 // 2303 2304 private static final Asn1Tag TAG_keplerCucType 2305 = Asn1Tag.fromClassAndNumber(-1, -1); 2306 2307 public keplerCucType() { 2308 super(); 2309 setValueRange("-32768", "32767"); 2310 2311 } 2312 2313 @Override 2314 @Nullable 2315 protected Asn1Tag getTag() { 2316 return TAG_keplerCucType; 2317 } 2318 2319 @Override 2320 protected boolean isTagImplicit() { 2321 return true; 2322 } 2323 2324 public static Collection<Asn1Tag> getPossibleFirstTags() { 2325 if (TAG_keplerCucType != null) { 2326 return ImmutableList.of(TAG_keplerCucType); 2327 } else { 2328 return Asn1Integer.getPossibleFirstTags(); 2329 } 2330 } 2331 2332 /** 2333 * Creates a new keplerCucType from encoded stream. 2334 */ 2335 public static keplerCucType fromPerUnaligned(byte[] encodedBytes) { 2336 keplerCucType result = new keplerCucType(); 2337 result.decodePerUnaligned(new BitStreamReader(encodedBytes)); 2338 return result; 2339 } 2340 2341 /** 2342 * Creates a new keplerCucType from encoded stream. 2343 */ 2344 public static keplerCucType fromPerAligned(byte[] encodedBytes) { 2345 keplerCucType result = new keplerCucType(); 2346 result.decodePerAligned(new BitStreamReader(encodedBytes)); 2347 return result; 2348 } 2349 2350 @Override public Iterable<BitStream> encodePerUnaligned() { 2351 return super.encodePerUnaligned(); 2352 } 2353 2354 @Override public Iterable<BitStream> encodePerAligned() { 2355 return super.encodePerAligned(); 2356 } 2357 2358 @Override public void decodePerUnaligned(BitStreamReader reader) { 2359 super.decodePerUnaligned(reader); 2360 } 2361 2362 @Override public void decodePerAligned(BitStreamReader reader) { 2363 super.decodePerAligned(reader); 2364 } 2365 2366 @Override public String toString() { 2367 return toIndentedString(""); 2368 } 2369 2370 public String toIndentedString(String indent) { 2371 return "keplerCucType = " + getInteger() + ";\n"; 2372 } 2373 } 2374 2375 2376 2377 2378 2379 @Override public Iterable<BitStream> encodePerUnaligned() { 2380 return super.encodePerUnaligned(); 2381 } 2382 2383 @Override public Iterable<BitStream> encodePerAligned() { 2384 return super.encodePerAligned(); 2385 } 2386 2387 @Override public void decodePerUnaligned(BitStreamReader reader) { 2388 super.decodePerUnaligned(reader); 2389 } 2390 2391 @Override public void decodePerAligned(BitStreamReader reader) { 2392 super.decodePerAligned(reader); 2393 } 2394 2395 @Override public String toString() { 2396 return toIndentedString(""); 2397 } 2398 2399 public String toIndentedString(String indent) { 2400 StringBuilder builder = new StringBuilder(); 2401 builder.append("NavModel_KeplerianSet = {\n"); 2402 final String internalIndent = indent + " "; 2403 for (SequenceComponent component : getComponents()) { 2404 if (component.isExplicitlySet()) { 2405 builder.append(internalIndent) 2406 .append(component.toIndentedString(internalIndent)); 2407 } 2408 } 2409 if (isExtensible()) { 2410 builder.append(internalIndent).append("...\n"); 2411 for (SequenceComponent component : getExtensionComponents()) { 2412 if (component.isExplicitlySet()) { 2413 builder.append(internalIndent) 2414 .append(component.toIndentedString(internalIndent)); 2415 } 2416 } 2417 } 2418 builder.append(indent).append("};\n"); 2419 return builder.toString(); 2420 } 2421 } 2422
