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