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.Asn1BitString; 26 import android.location.cts.asn1.base.Asn1Integer; 27 import android.location.cts.asn1.base.Asn1Null; 28 import android.location.cts.asn1.base.Asn1Object; 29 import android.location.cts.asn1.base.Asn1Sequence; 30 import android.location.cts.asn1.base.Asn1Tag; 31 import android.location.cts.asn1.base.BitStream; 32 import android.location.cts.asn1.base.BitStreamReader; 33 import android.location.cts.asn1.base.SequenceComponent; 34 import com.google.common.collect.ImmutableList; 35 import java.util.Collection; 36 import javax.annotation.Nullable; 37 38 39 /** 40 */ 41 public class Almanac_GlonassAlmanacSet extends Asn1Sequence { 42 // 43 44 private static final Asn1Tag TAG_Almanac_GlonassAlmanacSet 45 = Asn1Tag.fromClassAndNumber(-1, -1); 46 47 public Almanac_GlonassAlmanacSet() { 48 super(); 49 } 50 51 @Override 52 @Nullable 53 protected Asn1Tag getTag() { 54 return TAG_Almanac_GlonassAlmanacSet; 55 } 56 57 @Override 58 protected boolean isTagImplicit() { 59 return true; 60 } 61 62 public static Collection<Asn1Tag> getPossibleFirstTags() { 63 if (TAG_Almanac_GlonassAlmanacSet != null) { 64 return ImmutableList.of(TAG_Almanac_GlonassAlmanacSet); 65 } else { 66 return Asn1Sequence.getPossibleFirstTags(); 67 } 68 } 69 70 /** 71 * Creates a new Almanac_GlonassAlmanacSet from encoded stream. 72 */ 73 public static Almanac_GlonassAlmanacSet fromPerUnaligned(byte[] encodedBytes) { 74 Almanac_GlonassAlmanacSet result = new Almanac_GlonassAlmanacSet(); 75 result.decodePerUnaligned(new BitStreamReader(encodedBytes)); 76 return result; 77 } 78 79 /** 80 * Creates a new Almanac_GlonassAlmanacSet from encoded stream. 81 */ 82 public static Almanac_GlonassAlmanacSet fromPerAligned(byte[] encodedBytes) { 83 Almanac_GlonassAlmanacSet result = new Almanac_GlonassAlmanacSet(); 84 result.decodePerAligned(new BitStreamReader(encodedBytes)); 85 return result; 86 } 87 88 89 90 @Override protected boolean isExtensible() { 91 return false; 92 } 93 94 @Override public boolean containsExtensionValues() { 95 for (SequenceComponent extensionComponent : getExtensionComponents()) { 96 if (extensionComponent.isExplicitlySet()) return true; 97 } 98 return false; 99 } 100 101 102 private Almanac_GlonassAlmanacSet.gloAlmNAType gloAlmNA_; 103 public Almanac_GlonassAlmanacSet.gloAlmNAType getGloAlmNA() { 104 return gloAlmNA_; 105 } 106 /** 107 * @throws ClassCastException if value is not a Almanac_GlonassAlmanacSet.gloAlmNAType 108 */ 109 public void setGloAlmNA(Asn1Object value) { 110 this.gloAlmNA_ = (Almanac_GlonassAlmanacSet.gloAlmNAType) value; 111 } 112 public Almanac_GlonassAlmanacSet.gloAlmNAType setGloAlmNAToNewInstance() { 113 gloAlmNA_ = new Almanac_GlonassAlmanacSet.gloAlmNAType(); 114 return gloAlmNA_; 115 } 116 117 private Almanac_GlonassAlmanacSet.gloAlmnAType gloAlmnA_; 118 public Almanac_GlonassAlmanacSet.gloAlmnAType getGloAlmnA() { 119 return gloAlmnA_; 120 } 121 /** 122 * @throws ClassCastException if value is not a Almanac_GlonassAlmanacSet.gloAlmnAType 123 */ 124 public void setGloAlmnA(Asn1Object value) { 125 this.gloAlmnA_ = (Almanac_GlonassAlmanacSet.gloAlmnAType) value; 126 } 127 public Almanac_GlonassAlmanacSet.gloAlmnAType setGloAlmnAToNewInstance() { 128 gloAlmnA_ = new Almanac_GlonassAlmanacSet.gloAlmnAType(); 129 return gloAlmnA_; 130 } 131 132 private Almanac_GlonassAlmanacSet.gloAlmHAType gloAlmHA_; 133 public Almanac_GlonassAlmanacSet.gloAlmHAType getGloAlmHA() { 134 return gloAlmHA_; 135 } 136 /** 137 * @throws ClassCastException if value is not a Almanac_GlonassAlmanacSet.gloAlmHAType 138 */ 139 public void setGloAlmHA(Asn1Object value) { 140 this.gloAlmHA_ = (Almanac_GlonassAlmanacSet.gloAlmHAType) value; 141 } 142 public Almanac_GlonassAlmanacSet.gloAlmHAType setGloAlmHAToNewInstance() { 143 gloAlmHA_ = new Almanac_GlonassAlmanacSet.gloAlmHAType(); 144 return gloAlmHA_; 145 } 146 147 private Almanac_GlonassAlmanacSet.gloAlmLambdaAType gloAlmLambdaA_; 148 public Almanac_GlonassAlmanacSet.gloAlmLambdaAType getGloAlmLambdaA() { 149 return gloAlmLambdaA_; 150 } 151 /** 152 * @throws ClassCastException if value is not a Almanac_GlonassAlmanacSet.gloAlmLambdaAType 153 */ 154 public void setGloAlmLambdaA(Asn1Object value) { 155 this.gloAlmLambdaA_ = (Almanac_GlonassAlmanacSet.gloAlmLambdaAType) value; 156 } 157 public Almanac_GlonassAlmanacSet.gloAlmLambdaAType setGloAlmLambdaAToNewInstance() { 158 gloAlmLambdaA_ = new Almanac_GlonassAlmanacSet.gloAlmLambdaAType(); 159 return gloAlmLambdaA_; 160 } 161 162 private Almanac_GlonassAlmanacSet.gloAlmtlambdaAType gloAlmtlambdaA_; 163 public Almanac_GlonassAlmanacSet.gloAlmtlambdaAType getGloAlmtlambdaA() { 164 return gloAlmtlambdaA_; 165 } 166 /** 167 * @throws ClassCastException if value is not a Almanac_GlonassAlmanacSet.gloAlmtlambdaAType 168 */ 169 public void setGloAlmtlambdaA(Asn1Object value) { 170 this.gloAlmtlambdaA_ = (Almanac_GlonassAlmanacSet.gloAlmtlambdaAType) value; 171 } 172 public Almanac_GlonassAlmanacSet.gloAlmtlambdaAType setGloAlmtlambdaAToNewInstance() { 173 gloAlmtlambdaA_ = new Almanac_GlonassAlmanacSet.gloAlmtlambdaAType(); 174 return gloAlmtlambdaA_; 175 } 176 177 private Almanac_GlonassAlmanacSet.gloAlmDeltaIaType gloAlmDeltaIa_; 178 public Almanac_GlonassAlmanacSet.gloAlmDeltaIaType getGloAlmDeltaIa() { 179 return gloAlmDeltaIa_; 180 } 181 /** 182 * @throws ClassCastException if value is not a Almanac_GlonassAlmanacSet.gloAlmDeltaIaType 183 */ 184 public void setGloAlmDeltaIa(Asn1Object value) { 185 this.gloAlmDeltaIa_ = (Almanac_GlonassAlmanacSet.gloAlmDeltaIaType) value; 186 } 187 public Almanac_GlonassAlmanacSet.gloAlmDeltaIaType setGloAlmDeltaIaToNewInstance() { 188 gloAlmDeltaIa_ = new Almanac_GlonassAlmanacSet.gloAlmDeltaIaType(); 189 return gloAlmDeltaIa_; 190 } 191 192 private Almanac_GlonassAlmanacSet.gloAlmDeltaTAType gloAlmDeltaTA_; 193 public Almanac_GlonassAlmanacSet.gloAlmDeltaTAType getGloAlmDeltaTA() { 194 return gloAlmDeltaTA_; 195 } 196 /** 197 * @throws ClassCastException if value is not a Almanac_GlonassAlmanacSet.gloAlmDeltaTAType 198 */ 199 public void setGloAlmDeltaTA(Asn1Object value) { 200 this.gloAlmDeltaTA_ = (Almanac_GlonassAlmanacSet.gloAlmDeltaTAType) value; 201 } 202 public Almanac_GlonassAlmanacSet.gloAlmDeltaTAType setGloAlmDeltaTAToNewInstance() { 203 gloAlmDeltaTA_ = new Almanac_GlonassAlmanacSet.gloAlmDeltaTAType(); 204 return gloAlmDeltaTA_; 205 } 206 207 private Almanac_GlonassAlmanacSet.gloAlmDeltaTdotAType gloAlmDeltaTdotA_; 208 public Almanac_GlonassAlmanacSet.gloAlmDeltaTdotAType getGloAlmDeltaTdotA() { 209 return gloAlmDeltaTdotA_; 210 } 211 /** 212 * @throws ClassCastException if value is not a Almanac_GlonassAlmanacSet.gloAlmDeltaTdotAType 213 */ 214 public void setGloAlmDeltaTdotA(Asn1Object value) { 215 this.gloAlmDeltaTdotA_ = (Almanac_GlonassAlmanacSet.gloAlmDeltaTdotAType) value; 216 } 217 public Almanac_GlonassAlmanacSet.gloAlmDeltaTdotAType setGloAlmDeltaTdotAToNewInstance() { 218 gloAlmDeltaTdotA_ = new Almanac_GlonassAlmanacSet.gloAlmDeltaTdotAType(); 219 return gloAlmDeltaTdotA_; 220 } 221 222 private Almanac_GlonassAlmanacSet.gloAlmEpsilonAType gloAlmEpsilonA_; 223 public Almanac_GlonassAlmanacSet.gloAlmEpsilonAType getGloAlmEpsilonA() { 224 return gloAlmEpsilonA_; 225 } 226 /** 227 * @throws ClassCastException if value is not a Almanac_GlonassAlmanacSet.gloAlmEpsilonAType 228 */ 229 public void setGloAlmEpsilonA(Asn1Object value) { 230 this.gloAlmEpsilonA_ = (Almanac_GlonassAlmanacSet.gloAlmEpsilonAType) value; 231 } 232 public Almanac_GlonassAlmanacSet.gloAlmEpsilonAType setGloAlmEpsilonAToNewInstance() { 233 gloAlmEpsilonA_ = new Almanac_GlonassAlmanacSet.gloAlmEpsilonAType(); 234 return gloAlmEpsilonA_; 235 } 236 237 private Almanac_GlonassAlmanacSet.gloAlmOmegaAType gloAlmOmegaA_; 238 public Almanac_GlonassAlmanacSet.gloAlmOmegaAType getGloAlmOmegaA() { 239 return gloAlmOmegaA_; 240 } 241 /** 242 * @throws ClassCastException if value is not a Almanac_GlonassAlmanacSet.gloAlmOmegaAType 243 */ 244 public void setGloAlmOmegaA(Asn1Object value) { 245 this.gloAlmOmegaA_ = (Almanac_GlonassAlmanacSet.gloAlmOmegaAType) value; 246 } 247 public Almanac_GlonassAlmanacSet.gloAlmOmegaAType setGloAlmOmegaAToNewInstance() { 248 gloAlmOmegaA_ = new Almanac_GlonassAlmanacSet.gloAlmOmegaAType(); 249 return gloAlmOmegaA_; 250 } 251 252 private Almanac_GlonassAlmanacSet.gloAlmTauAType gloAlmTauA_; 253 public Almanac_GlonassAlmanacSet.gloAlmTauAType getGloAlmTauA() { 254 return gloAlmTauA_; 255 } 256 /** 257 * @throws ClassCastException if value is not a Almanac_GlonassAlmanacSet.gloAlmTauAType 258 */ 259 public void setGloAlmTauA(Asn1Object value) { 260 this.gloAlmTauA_ = (Almanac_GlonassAlmanacSet.gloAlmTauAType) value; 261 } 262 public Almanac_GlonassAlmanacSet.gloAlmTauAType setGloAlmTauAToNewInstance() { 263 gloAlmTauA_ = new Almanac_GlonassAlmanacSet.gloAlmTauAType(); 264 return gloAlmTauA_; 265 } 266 267 private Almanac_GlonassAlmanacSet.gloAlmCAType gloAlmCA_; 268 public Almanac_GlonassAlmanacSet.gloAlmCAType getGloAlmCA() { 269 return gloAlmCA_; 270 } 271 /** 272 * @throws ClassCastException if value is not a Almanac_GlonassAlmanacSet.gloAlmCAType 273 */ 274 public void setGloAlmCA(Asn1Object value) { 275 this.gloAlmCA_ = (Almanac_GlonassAlmanacSet.gloAlmCAType) value; 276 } 277 public Almanac_GlonassAlmanacSet.gloAlmCAType setGloAlmCAToNewInstance() { 278 gloAlmCA_ = new Almanac_GlonassAlmanacSet.gloAlmCAType(); 279 return gloAlmCA_; 280 } 281 282 private Almanac_GlonassAlmanacSet.gloAlmMAType gloAlmMA_; 283 public Almanac_GlonassAlmanacSet.gloAlmMAType getGloAlmMA() { 284 return gloAlmMA_; 285 } 286 /** 287 * @throws ClassCastException if value is not a Almanac_GlonassAlmanacSet.gloAlmMAType 288 */ 289 public void setGloAlmMA(Asn1Object value) { 290 this.gloAlmMA_ = (Almanac_GlonassAlmanacSet.gloAlmMAType) value; 291 } 292 public Almanac_GlonassAlmanacSet.gloAlmMAType setGloAlmMAToNewInstance() { 293 gloAlmMA_ = new Almanac_GlonassAlmanacSet.gloAlmMAType(); 294 return gloAlmMA_; 295 } 296 297 298 299 300 301 302 @Override public Iterable<? extends SequenceComponent> getComponents() { 303 ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder(); 304 305 builder.add(new SequenceComponent() { 306 Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0); 307 308 @Override public boolean isExplicitlySet() { 309 return getGloAlmNA() != null; 310 } 311 312 @Override public boolean hasDefaultValue() { 313 return false; 314 } 315 316 @Override public boolean isOptional() { 317 return false; 318 } 319 320 @Override public Asn1Object getComponentValue() { 321 return getGloAlmNA(); 322 } 323 324 @Override public void setToNewInstance() { 325 setGloAlmNAToNewInstance(); 326 } 327 328 @Override public Collection<Asn1Tag> getPossibleFirstTags() { 329 return tag == null ? Almanac_GlonassAlmanacSet.gloAlmNAType.getPossibleFirstTags() : ImmutableList.of(tag); 330 } 331 332 @Override 333 public Asn1Tag getTag() { 334 return tag; 335 } 336 337 @Override 338 public boolean isImplicitTagging() { 339 return true; 340 } 341 342 @Override public String toIndentedString(String indent) { 343 return "gloAlmNA : " 344 + getGloAlmNA().toIndentedString(indent); 345 } 346 }); 347 348 builder.add(new SequenceComponent() { 349 Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1); 350 351 @Override public boolean isExplicitlySet() { 352 return getGloAlmnA() != null; 353 } 354 355 @Override public boolean hasDefaultValue() { 356 return false; 357 } 358 359 @Override public boolean isOptional() { 360 return false; 361 } 362 363 @Override public Asn1Object getComponentValue() { 364 return getGloAlmnA(); 365 } 366 367 @Override public void setToNewInstance() { 368 setGloAlmnAToNewInstance(); 369 } 370 371 @Override public Collection<Asn1Tag> getPossibleFirstTags() { 372 return tag == null ? Almanac_GlonassAlmanacSet.gloAlmnAType.getPossibleFirstTags() : ImmutableList.of(tag); 373 } 374 375 @Override 376 public Asn1Tag getTag() { 377 return tag; 378 } 379 380 @Override 381 public boolean isImplicitTagging() { 382 return true; 383 } 384 385 @Override public String toIndentedString(String indent) { 386 return "gloAlmnA : " 387 + getGloAlmnA().toIndentedString(indent); 388 } 389 }); 390 391 builder.add(new SequenceComponent() { 392 Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2); 393 394 @Override public boolean isExplicitlySet() { 395 return getGloAlmHA() != null; 396 } 397 398 @Override public boolean hasDefaultValue() { 399 return false; 400 } 401 402 @Override public boolean isOptional() { 403 return false; 404 } 405 406 @Override public Asn1Object getComponentValue() { 407 return getGloAlmHA(); 408 } 409 410 @Override public void setToNewInstance() { 411 setGloAlmHAToNewInstance(); 412 } 413 414 @Override public Collection<Asn1Tag> getPossibleFirstTags() { 415 return tag == null ? Almanac_GlonassAlmanacSet.gloAlmHAType.getPossibleFirstTags() : ImmutableList.of(tag); 416 } 417 418 @Override 419 public Asn1Tag getTag() { 420 return tag; 421 } 422 423 @Override 424 public boolean isImplicitTagging() { 425 return true; 426 } 427 428 @Override public String toIndentedString(String indent) { 429 return "gloAlmHA : " 430 + getGloAlmHA().toIndentedString(indent); 431 } 432 }); 433 434 builder.add(new SequenceComponent() { 435 Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3); 436 437 @Override public boolean isExplicitlySet() { 438 return getGloAlmLambdaA() != null; 439 } 440 441 @Override public boolean hasDefaultValue() { 442 return false; 443 } 444 445 @Override public boolean isOptional() { 446 return false; 447 } 448 449 @Override public Asn1Object getComponentValue() { 450 return getGloAlmLambdaA(); 451 } 452 453 @Override public void setToNewInstance() { 454 setGloAlmLambdaAToNewInstance(); 455 } 456 457 @Override public Collection<Asn1Tag> getPossibleFirstTags() { 458 return tag == null ? Almanac_GlonassAlmanacSet.gloAlmLambdaAType.getPossibleFirstTags() : ImmutableList.of(tag); 459 } 460 461 @Override 462 public Asn1Tag getTag() { 463 return tag; 464 } 465 466 @Override 467 public boolean isImplicitTagging() { 468 return true; 469 } 470 471 @Override public String toIndentedString(String indent) { 472 return "gloAlmLambdaA : " 473 + getGloAlmLambdaA().toIndentedString(indent); 474 } 475 }); 476 477 builder.add(new SequenceComponent() { 478 Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4); 479 480 @Override public boolean isExplicitlySet() { 481 return getGloAlmtlambdaA() != null; 482 } 483 484 @Override public boolean hasDefaultValue() { 485 return false; 486 } 487 488 @Override public boolean isOptional() { 489 return false; 490 } 491 492 @Override public Asn1Object getComponentValue() { 493 return getGloAlmtlambdaA(); 494 } 495 496 @Override public void setToNewInstance() { 497 setGloAlmtlambdaAToNewInstance(); 498 } 499 500 @Override public Collection<Asn1Tag> getPossibleFirstTags() { 501 return tag == null ? Almanac_GlonassAlmanacSet.gloAlmtlambdaAType.getPossibleFirstTags() : ImmutableList.of(tag); 502 } 503 504 @Override 505 public Asn1Tag getTag() { 506 return tag; 507 } 508 509 @Override 510 public boolean isImplicitTagging() { 511 return true; 512 } 513 514 @Override public String toIndentedString(String indent) { 515 return "gloAlmtlambdaA : " 516 + getGloAlmtlambdaA().toIndentedString(indent); 517 } 518 }); 519 520 builder.add(new SequenceComponent() { 521 Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 5); 522 523 @Override public boolean isExplicitlySet() { 524 return getGloAlmDeltaIa() != null; 525 } 526 527 @Override public boolean hasDefaultValue() { 528 return false; 529 } 530 531 @Override public boolean isOptional() { 532 return false; 533 } 534 535 @Override public Asn1Object getComponentValue() { 536 return getGloAlmDeltaIa(); 537 } 538 539 @Override public void setToNewInstance() { 540 setGloAlmDeltaIaToNewInstance(); 541 } 542 543 @Override public Collection<Asn1Tag> getPossibleFirstTags() { 544 return tag == null ? Almanac_GlonassAlmanacSet.gloAlmDeltaIaType.getPossibleFirstTags() : ImmutableList.of(tag); 545 } 546 547 @Override 548 public Asn1Tag getTag() { 549 return tag; 550 } 551 552 @Override 553 public boolean isImplicitTagging() { 554 return true; 555 } 556 557 @Override public String toIndentedString(String indent) { 558 return "gloAlmDeltaIa : " 559 + getGloAlmDeltaIa().toIndentedString(indent); 560 } 561 }); 562 563 builder.add(new SequenceComponent() { 564 Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 6); 565 566 @Override public boolean isExplicitlySet() { 567 return getGloAlmDeltaTA() != null; 568 } 569 570 @Override public boolean hasDefaultValue() { 571 return false; 572 } 573 574 @Override public boolean isOptional() { 575 return false; 576 } 577 578 @Override public Asn1Object getComponentValue() { 579 return getGloAlmDeltaTA(); 580 } 581 582 @Override public void setToNewInstance() { 583 setGloAlmDeltaTAToNewInstance(); 584 } 585 586 @Override public Collection<Asn1Tag> getPossibleFirstTags() { 587 return tag == null ? Almanac_GlonassAlmanacSet.gloAlmDeltaTAType.getPossibleFirstTags() : ImmutableList.of(tag); 588 } 589 590 @Override 591 public Asn1Tag getTag() { 592 return tag; 593 } 594 595 @Override 596 public boolean isImplicitTagging() { 597 return true; 598 } 599 600 @Override public String toIndentedString(String indent) { 601 return "gloAlmDeltaTA : " 602 + getGloAlmDeltaTA().toIndentedString(indent); 603 } 604 }); 605 606 builder.add(new SequenceComponent() { 607 Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 7); 608 609 @Override public boolean isExplicitlySet() { 610 return getGloAlmDeltaTdotA() != null; 611 } 612 613 @Override public boolean hasDefaultValue() { 614 return false; 615 } 616 617 @Override public boolean isOptional() { 618 return false; 619 } 620 621 @Override public Asn1Object getComponentValue() { 622 return getGloAlmDeltaTdotA(); 623 } 624 625 @Override public void setToNewInstance() { 626 setGloAlmDeltaTdotAToNewInstance(); 627 } 628 629 @Override public Collection<Asn1Tag> getPossibleFirstTags() { 630 return tag == null ? Almanac_GlonassAlmanacSet.gloAlmDeltaTdotAType.getPossibleFirstTags() : ImmutableList.of(tag); 631 } 632 633 @Override 634 public Asn1Tag getTag() { 635 return tag; 636 } 637 638 @Override 639 public boolean isImplicitTagging() { 640 return true; 641 } 642 643 @Override public String toIndentedString(String indent) { 644 return "gloAlmDeltaTdotA : " 645 + getGloAlmDeltaTdotA().toIndentedString(indent); 646 } 647 }); 648 649 builder.add(new SequenceComponent() { 650 Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 8); 651 652 @Override public boolean isExplicitlySet() { 653 return getGloAlmEpsilonA() != null; 654 } 655 656 @Override public boolean hasDefaultValue() { 657 return false; 658 } 659 660 @Override public boolean isOptional() { 661 return false; 662 } 663 664 @Override public Asn1Object getComponentValue() { 665 return getGloAlmEpsilonA(); 666 } 667 668 @Override public void setToNewInstance() { 669 setGloAlmEpsilonAToNewInstance(); 670 } 671 672 @Override public Collection<Asn1Tag> getPossibleFirstTags() { 673 return tag == null ? Almanac_GlonassAlmanacSet.gloAlmEpsilonAType.getPossibleFirstTags() : ImmutableList.of(tag); 674 } 675 676 @Override 677 public Asn1Tag getTag() { 678 return tag; 679 } 680 681 @Override 682 public boolean isImplicitTagging() { 683 return true; 684 } 685 686 @Override public String toIndentedString(String indent) { 687 return "gloAlmEpsilonA : " 688 + getGloAlmEpsilonA().toIndentedString(indent); 689 } 690 }); 691 692 builder.add(new SequenceComponent() { 693 Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 9); 694 695 @Override public boolean isExplicitlySet() { 696 return getGloAlmOmegaA() != null; 697 } 698 699 @Override public boolean hasDefaultValue() { 700 return false; 701 } 702 703 @Override public boolean isOptional() { 704 return false; 705 } 706 707 @Override public Asn1Object getComponentValue() { 708 return getGloAlmOmegaA(); 709 } 710 711 @Override public void setToNewInstance() { 712 setGloAlmOmegaAToNewInstance(); 713 } 714 715 @Override public Collection<Asn1Tag> getPossibleFirstTags() { 716 return tag == null ? Almanac_GlonassAlmanacSet.gloAlmOmegaAType.getPossibleFirstTags() : ImmutableList.of(tag); 717 } 718 719 @Override 720 public Asn1Tag getTag() { 721 return tag; 722 } 723 724 @Override 725 public boolean isImplicitTagging() { 726 return true; 727 } 728 729 @Override public String toIndentedString(String indent) { 730 return "gloAlmOmegaA : " 731 + getGloAlmOmegaA().toIndentedString(indent); 732 } 733 }); 734 735 builder.add(new SequenceComponent() { 736 Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 10); 737 738 @Override public boolean isExplicitlySet() { 739 return getGloAlmTauA() != null; 740 } 741 742 @Override public boolean hasDefaultValue() { 743 return false; 744 } 745 746 @Override public boolean isOptional() { 747 return false; 748 } 749 750 @Override public Asn1Object getComponentValue() { 751 return getGloAlmTauA(); 752 } 753 754 @Override public void setToNewInstance() { 755 setGloAlmTauAToNewInstance(); 756 } 757 758 @Override public Collection<Asn1Tag> getPossibleFirstTags() { 759 return tag == null ? Almanac_GlonassAlmanacSet.gloAlmTauAType.getPossibleFirstTags() : ImmutableList.of(tag); 760 } 761 762 @Override 763 public Asn1Tag getTag() { 764 return tag; 765 } 766 767 @Override 768 public boolean isImplicitTagging() { 769 return true; 770 } 771 772 @Override public String toIndentedString(String indent) { 773 return "gloAlmTauA : " 774 + getGloAlmTauA().toIndentedString(indent); 775 } 776 }); 777 778 builder.add(new SequenceComponent() { 779 Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 11); 780 781 @Override public boolean isExplicitlySet() { 782 return getGloAlmCA() != null; 783 } 784 785 @Override public boolean hasDefaultValue() { 786 return false; 787 } 788 789 @Override public boolean isOptional() { 790 return false; 791 } 792 793 @Override public Asn1Object getComponentValue() { 794 return getGloAlmCA(); 795 } 796 797 @Override public void setToNewInstance() { 798 setGloAlmCAToNewInstance(); 799 } 800 801 @Override public Collection<Asn1Tag> getPossibleFirstTags() { 802 return tag == null ? Almanac_GlonassAlmanacSet.gloAlmCAType.getPossibleFirstTags() : ImmutableList.of(tag); 803 } 804 805 @Override 806 public Asn1Tag getTag() { 807 return tag; 808 } 809 810 @Override 811 public boolean isImplicitTagging() { 812 return true; 813 } 814 815 @Override public String toIndentedString(String indent) { 816 return "gloAlmCA : " 817 + getGloAlmCA().toIndentedString(indent); 818 } 819 }); 820 821 builder.add(new SequenceComponent() { 822 Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 12); 823 824 @Override public boolean isExplicitlySet() { 825 return getGloAlmMA() != null; 826 } 827 828 @Override public boolean hasDefaultValue() { 829 return false; 830 } 831 832 @Override public boolean isOptional() { 833 return true; 834 } 835 836 @Override public Asn1Object getComponentValue() { 837 return getGloAlmMA(); 838 } 839 840 @Override public void setToNewInstance() { 841 setGloAlmMAToNewInstance(); 842 } 843 844 @Override public Collection<Asn1Tag> getPossibleFirstTags() { 845 return tag == null ? Almanac_GlonassAlmanacSet.gloAlmMAType.getPossibleFirstTags() : ImmutableList.of(tag); 846 } 847 848 @Override 849 public Asn1Tag getTag() { 850 return tag; 851 } 852 853 @Override 854 public boolean isImplicitTagging() { 855 return true; 856 } 857 858 @Override public String toIndentedString(String indent) { 859 return "gloAlmMA : " 860 + getGloAlmMA().toIndentedString(indent); 861 } 862 }); 863 864 return builder.build(); 865 } 866 867 @Override public Iterable<? extends SequenceComponent> 868 getExtensionComponents() { 869 ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder(); 870 871 return builder.build(); 872 } 873 874 875 /* 876 */ 877 878 879 // 880 881 /** 882 */ 883 public static class gloAlmNAType extends Asn1Integer { 884 // 885 886 private static final Asn1Tag TAG_gloAlmNAType 887 = Asn1Tag.fromClassAndNumber(-1, -1); 888 889 public gloAlmNAType() { 890 super(); 891 setValueRange("1", "1461"); 892 893 } 894 895 @Override 896 @Nullable 897 protected Asn1Tag getTag() { 898 return TAG_gloAlmNAType; 899 } 900 901 @Override 902 protected boolean isTagImplicit() { 903 return true; 904 } 905 906 public static Collection<Asn1Tag> getPossibleFirstTags() { 907 if (TAG_gloAlmNAType != null) { 908 return ImmutableList.of(TAG_gloAlmNAType); 909 } else { 910 return Asn1Integer.getPossibleFirstTags(); 911 } 912 } 913 914 /** 915 * Creates a new gloAlmNAType from encoded stream. 916 */ 917 public static gloAlmNAType fromPerUnaligned(byte[] encodedBytes) { 918 gloAlmNAType result = new gloAlmNAType(); 919 result.decodePerUnaligned(new BitStreamReader(encodedBytes)); 920 return result; 921 } 922 923 /** 924 * Creates a new gloAlmNAType from encoded stream. 925 */ 926 public static gloAlmNAType fromPerAligned(byte[] encodedBytes) { 927 gloAlmNAType result = new gloAlmNAType(); 928 result.decodePerAligned(new BitStreamReader(encodedBytes)); 929 return result; 930 } 931 932 @Override public Iterable<BitStream> encodePerUnaligned() { 933 return super.encodePerUnaligned(); 934 } 935 936 @Override public Iterable<BitStream> encodePerAligned() { 937 return super.encodePerAligned(); 938 } 939 940 @Override public void decodePerUnaligned(BitStreamReader reader) { 941 super.decodePerUnaligned(reader); 942 } 943 944 @Override public void decodePerAligned(BitStreamReader reader) { 945 super.decodePerAligned(reader); 946 } 947 948 @Override public String toString() { 949 return toIndentedString(""); 950 } 951 952 public String toIndentedString(String indent) { 953 return "gloAlmNAType = " + getInteger() + ";\n"; 954 } 955 } 956 957 958 /* 959 */ 960 961 962 // 963 964 /** 965 */ 966 public static class gloAlmnAType extends Asn1Integer { 967 // 968 969 private static final Asn1Tag TAG_gloAlmnAType 970 = Asn1Tag.fromClassAndNumber(-1, -1); 971 972 public gloAlmnAType() { 973 super(); 974 setValueRange("1", "24"); 975 976 } 977 978 @Override 979 @Nullable 980 protected Asn1Tag getTag() { 981 return TAG_gloAlmnAType; 982 } 983 984 @Override 985 protected boolean isTagImplicit() { 986 return true; 987 } 988 989 public static Collection<Asn1Tag> getPossibleFirstTags() { 990 if (TAG_gloAlmnAType != null) { 991 return ImmutableList.of(TAG_gloAlmnAType); 992 } else { 993 return Asn1Integer.getPossibleFirstTags(); 994 } 995 } 996 997 /** 998 * Creates a new gloAlmnAType from encoded stream. 999 */ 1000 public static gloAlmnAType fromPerUnaligned(byte[] encodedBytes) { 1001 gloAlmnAType result = new gloAlmnAType(); 1002 result.decodePerUnaligned(new BitStreamReader(encodedBytes)); 1003 return result; 1004 } 1005 1006 /** 1007 * Creates a new gloAlmnAType from encoded stream. 1008 */ 1009 public static gloAlmnAType fromPerAligned(byte[] encodedBytes) { 1010 gloAlmnAType result = new gloAlmnAType(); 1011 result.decodePerAligned(new BitStreamReader(encodedBytes)); 1012 return result; 1013 } 1014 1015 @Override public Iterable<BitStream> encodePerUnaligned() { 1016 return super.encodePerUnaligned(); 1017 } 1018 1019 @Override public Iterable<BitStream> encodePerAligned() { 1020 return super.encodePerAligned(); 1021 } 1022 1023 @Override public void decodePerUnaligned(BitStreamReader reader) { 1024 super.decodePerUnaligned(reader); 1025 } 1026 1027 @Override public void decodePerAligned(BitStreamReader reader) { 1028 super.decodePerAligned(reader); 1029 } 1030 1031 @Override public String toString() { 1032 return toIndentedString(""); 1033 } 1034 1035 public String toIndentedString(String indent) { 1036 return "gloAlmnAType = " + getInteger() + ";\n"; 1037 } 1038 } 1039 1040 1041 /* 1042 */ 1043 1044 1045 // 1046 1047 /** 1048 */ 1049 public static class gloAlmHAType extends Asn1Integer { 1050 // 1051 1052 private static final Asn1Tag TAG_gloAlmHAType 1053 = Asn1Tag.fromClassAndNumber(-1, -1); 1054 1055 public gloAlmHAType() { 1056 super(); 1057 setValueRange("0", "31"); 1058 1059 } 1060 1061 @Override 1062 @Nullable 1063 protected Asn1Tag getTag() { 1064 return TAG_gloAlmHAType; 1065 } 1066 1067 @Override 1068 protected boolean isTagImplicit() { 1069 return true; 1070 } 1071 1072 public static Collection<Asn1Tag> getPossibleFirstTags() { 1073 if (TAG_gloAlmHAType != null) { 1074 return ImmutableList.of(TAG_gloAlmHAType); 1075 } else { 1076 return Asn1Integer.getPossibleFirstTags(); 1077 } 1078 } 1079 1080 /** 1081 * Creates a new gloAlmHAType from encoded stream. 1082 */ 1083 public static gloAlmHAType fromPerUnaligned(byte[] encodedBytes) { 1084 gloAlmHAType result = new gloAlmHAType(); 1085 result.decodePerUnaligned(new BitStreamReader(encodedBytes)); 1086 return result; 1087 } 1088 1089 /** 1090 * Creates a new gloAlmHAType from encoded stream. 1091 */ 1092 public static gloAlmHAType fromPerAligned(byte[] encodedBytes) { 1093 gloAlmHAType result = new gloAlmHAType(); 1094 result.decodePerAligned(new BitStreamReader(encodedBytes)); 1095 return result; 1096 } 1097 1098 @Override public Iterable<BitStream> encodePerUnaligned() { 1099 return super.encodePerUnaligned(); 1100 } 1101 1102 @Override public Iterable<BitStream> encodePerAligned() { 1103 return super.encodePerAligned(); 1104 } 1105 1106 @Override public void decodePerUnaligned(BitStreamReader reader) { 1107 super.decodePerUnaligned(reader); 1108 } 1109 1110 @Override public void decodePerAligned(BitStreamReader reader) { 1111 super.decodePerAligned(reader); 1112 } 1113 1114 @Override public String toString() { 1115 return toIndentedString(""); 1116 } 1117 1118 public String toIndentedString(String indent) { 1119 return "gloAlmHAType = " + getInteger() + ";\n"; 1120 } 1121 } 1122 1123 1124 /* 1125 */ 1126 1127 1128 // 1129 1130 /** 1131 */ 1132 public static class gloAlmLambdaAType extends Asn1Integer { 1133 // 1134 1135 private static final Asn1Tag TAG_gloAlmLambdaAType 1136 = Asn1Tag.fromClassAndNumber(-1, -1); 1137 1138 public gloAlmLambdaAType() { 1139 super(); 1140 setValueRange("-1048576", "1048575"); 1141 1142 } 1143 1144 @Override 1145 @Nullable 1146 protected Asn1Tag getTag() { 1147 return TAG_gloAlmLambdaAType; 1148 } 1149 1150 @Override 1151 protected boolean isTagImplicit() { 1152 return true; 1153 } 1154 1155 public static Collection<Asn1Tag> getPossibleFirstTags() { 1156 if (TAG_gloAlmLambdaAType != null) { 1157 return ImmutableList.of(TAG_gloAlmLambdaAType); 1158 } else { 1159 return Asn1Integer.getPossibleFirstTags(); 1160 } 1161 } 1162 1163 /** 1164 * Creates a new gloAlmLambdaAType from encoded stream. 1165 */ 1166 public static gloAlmLambdaAType fromPerUnaligned(byte[] encodedBytes) { 1167 gloAlmLambdaAType result = new gloAlmLambdaAType(); 1168 result.decodePerUnaligned(new BitStreamReader(encodedBytes)); 1169 return result; 1170 } 1171 1172 /** 1173 * Creates a new gloAlmLambdaAType from encoded stream. 1174 */ 1175 public static gloAlmLambdaAType fromPerAligned(byte[] encodedBytes) { 1176 gloAlmLambdaAType result = new gloAlmLambdaAType(); 1177 result.decodePerAligned(new BitStreamReader(encodedBytes)); 1178 return result; 1179 } 1180 1181 @Override public Iterable<BitStream> encodePerUnaligned() { 1182 return super.encodePerUnaligned(); 1183 } 1184 1185 @Override public Iterable<BitStream> encodePerAligned() { 1186 return super.encodePerAligned(); 1187 } 1188 1189 @Override public void decodePerUnaligned(BitStreamReader reader) { 1190 super.decodePerUnaligned(reader); 1191 } 1192 1193 @Override public void decodePerAligned(BitStreamReader reader) { 1194 super.decodePerAligned(reader); 1195 } 1196 1197 @Override public String toString() { 1198 return toIndentedString(""); 1199 } 1200 1201 public String toIndentedString(String indent) { 1202 return "gloAlmLambdaAType = " + getInteger() + ";\n"; 1203 } 1204 } 1205 1206 1207 /* 1208 */ 1209 1210 1211 // 1212 1213 /** 1214 */ 1215 public static class gloAlmtlambdaAType extends Asn1Integer { 1216 // 1217 1218 private static final Asn1Tag TAG_gloAlmtlambdaAType 1219 = Asn1Tag.fromClassAndNumber(-1, -1); 1220 1221 public gloAlmtlambdaAType() { 1222 super(); 1223 setValueRange("0", "2097151"); 1224 1225 } 1226 1227 @Override 1228 @Nullable 1229 protected Asn1Tag getTag() { 1230 return TAG_gloAlmtlambdaAType; 1231 } 1232 1233 @Override 1234 protected boolean isTagImplicit() { 1235 return true; 1236 } 1237 1238 public static Collection<Asn1Tag> getPossibleFirstTags() { 1239 if (TAG_gloAlmtlambdaAType != null) { 1240 return ImmutableList.of(TAG_gloAlmtlambdaAType); 1241 } else { 1242 return Asn1Integer.getPossibleFirstTags(); 1243 } 1244 } 1245 1246 /** 1247 * Creates a new gloAlmtlambdaAType from encoded stream. 1248 */ 1249 public static gloAlmtlambdaAType fromPerUnaligned(byte[] encodedBytes) { 1250 gloAlmtlambdaAType result = new gloAlmtlambdaAType(); 1251 result.decodePerUnaligned(new BitStreamReader(encodedBytes)); 1252 return result; 1253 } 1254 1255 /** 1256 * Creates a new gloAlmtlambdaAType from encoded stream. 1257 */ 1258 public static gloAlmtlambdaAType fromPerAligned(byte[] encodedBytes) { 1259 gloAlmtlambdaAType result = new gloAlmtlambdaAType(); 1260 result.decodePerAligned(new BitStreamReader(encodedBytes)); 1261 return result; 1262 } 1263 1264 @Override public Iterable<BitStream> encodePerUnaligned() { 1265 return super.encodePerUnaligned(); 1266 } 1267 1268 @Override public Iterable<BitStream> encodePerAligned() { 1269 return super.encodePerAligned(); 1270 } 1271 1272 @Override public void decodePerUnaligned(BitStreamReader reader) { 1273 super.decodePerUnaligned(reader); 1274 } 1275 1276 @Override public void decodePerAligned(BitStreamReader reader) { 1277 super.decodePerAligned(reader); 1278 } 1279 1280 @Override public String toString() { 1281 return toIndentedString(""); 1282 } 1283 1284 public String toIndentedString(String indent) { 1285 return "gloAlmtlambdaAType = " + getInteger() + ";\n"; 1286 } 1287 } 1288 1289 1290 /* 1291 */ 1292 1293 1294 // 1295 1296 /** 1297 */ 1298 public static class gloAlmDeltaIaType extends Asn1Integer { 1299 // 1300 1301 private static final Asn1Tag TAG_gloAlmDeltaIaType 1302 = Asn1Tag.fromClassAndNumber(-1, -1); 1303 1304 public gloAlmDeltaIaType() { 1305 super(); 1306 setValueRange("-131072", "131071"); 1307 1308 } 1309 1310 @Override 1311 @Nullable 1312 protected Asn1Tag getTag() { 1313 return TAG_gloAlmDeltaIaType; 1314 } 1315 1316 @Override 1317 protected boolean isTagImplicit() { 1318 return true; 1319 } 1320 1321 public static Collection<Asn1Tag> getPossibleFirstTags() { 1322 if (TAG_gloAlmDeltaIaType != null) { 1323 return ImmutableList.of(TAG_gloAlmDeltaIaType); 1324 } else { 1325 return Asn1Integer.getPossibleFirstTags(); 1326 } 1327 } 1328 1329 /** 1330 * Creates a new gloAlmDeltaIaType from encoded stream. 1331 */ 1332 public static gloAlmDeltaIaType fromPerUnaligned(byte[] encodedBytes) { 1333 gloAlmDeltaIaType result = new gloAlmDeltaIaType(); 1334 result.decodePerUnaligned(new BitStreamReader(encodedBytes)); 1335 return result; 1336 } 1337 1338 /** 1339 * Creates a new gloAlmDeltaIaType from encoded stream. 1340 */ 1341 public static gloAlmDeltaIaType fromPerAligned(byte[] encodedBytes) { 1342 gloAlmDeltaIaType result = new gloAlmDeltaIaType(); 1343 result.decodePerAligned(new BitStreamReader(encodedBytes)); 1344 return result; 1345 } 1346 1347 @Override public Iterable<BitStream> encodePerUnaligned() { 1348 return super.encodePerUnaligned(); 1349 } 1350 1351 @Override public Iterable<BitStream> encodePerAligned() { 1352 return super.encodePerAligned(); 1353 } 1354 1355 @Override public void decodePerUnaligned(BitStreamReader reader) { 1356 super.decodePerUnaligned(reader); 1357 } 1358 1359 @Override public void decodePerAligned(BitStreamReader reader) { 1360 super.decodePerAligned(reader); 1361 } 1362 1363 @Override public String toString() { 1364 return toIndentedString(""); 1365 } 1366 1367 public String toIndentedString(String indent) { 1368 return "gloAlmDeltaIaType = " + getInteger() + ";\n"; 1369 } 1370 } 1371 1372 1373 /* 1374 */ 1375 1376 1377 // 1378 1379 /** 1380 */ 1381 public static class gloAlmDeltaTAType extends Asn1Integer { 1382 // 1383 1384 private static final Asn1Tag TAG_gloAlmDeltaTAType 1385 = Asn1Tag.fromClassAndNumber(-1, -1); 1386 1387 public gloAlmDeltaTAType() { 1388 super(); 1389 setValueRange("-2097152", "2097151"); 1390 1391 } 1392 1393 @Override 1394 @Nullable 1395 protected Asn1Tag getTag() { 1396 return TAG_gloAlmDeltaTAType; 1397 } 1398 1399 @Override 1400 protected boolean isTagImplicit() { 1401 return true; 1402 } 1403 1404 public static Collection<Asn1Tag> getPossibleFirstTags() { 1405 if (TAG_gloAlmDeltaTAType != null) { 1406 return ImmutableList.of(TAG_gloAlmDeltaTAType); 1407 } else { 1408 return Asn1Integer.getPossibleFirstTags(); 1409 } 1410 } 1411 1412 /** 1413 * Creates a new gloAlmDeltaTAType from encoded stream. 1414 */ 1415 public static gloAlmDeltaTAType fromPerUnaligned(byte[] encodedBytes) { 1416 gloAlmDeltaTAType result = new gloAlmDeltaTAType(); 1417 result.decodePerUnaligned(new BitStreamReader(encodedBytes)); 1418 return result; 1419 } 1420 1421 /** 1422 * Creates a new gloAlmDeltaTAType from encoded stream. 1423 */ 1424 public static gloAlmDeltaTAType fromPerAligned(byte[] encodedBytes) { 1425 gloAlmDeltaTAType result = new gloAlmDeltaTAType(); 1426 result.decodePerAligned(new BitStreamReader(encodedBytes)); 1427 return result; 1428 } 1429 1430 @Override public Iterable<BitStream> encodePerUnaligned() { 1431 return super.encodePerUnaligned(); 1432 } 1433 1434 @Override public Iterable<BitStream> encodePerAligned() { 1435 return super.encodePerAligned(); 1436 } 1437 1438 @Override public void decodePerUnaligned(BitStreamReader reader) { 1439 super.decodePerUnaligned(reader); 1440 } 1441 1442 @Override public void decodePerAligned(BitStreamReader reader) { 1443 super.decodePerAligned(reader); 1444 } 1445 1446 @Override public String toString() { 1447 return toIndentedString(""); 1448 } 1449 1450 public String toIndentedString(String indent) { 1451 return "gloAlmDeltaTAType = " + getInteger() + ";\n"; 1452 } 1453 } 1454 1455 1456 /* 1457 */ 1458 1459 1460 // 1461 1462 /** 1463 */ 1464 public static class gloAlmDeltaTdotAType extends Asn1Integer { 1465 // 1466 1467 private static final Asn1Tag TAG_gloAlmDeltaTdotAType 1468 = Asn1Tag.fromClassAndNumber(-1, -1); 1469 1470 public gloAlmDeltaTdotAType() { 1471 super(); 1472 setValueRange("-64", "63"); 1473 1474 } 1475 1476 @Override 1477 @Nullable 1478 protected Asn1Tag getTag() { 1479 return TAG_gloAlmDeltaTdotAType; 1480 } 1481 1482 @Override 1483 protected boolean isTagImplicit() { 1484 return true; 1485 } 1486 1487 public static Collection<Asn1Tag> getPossibleFirstTags() { 1488 if (TAG_gloAlmDeltaTdotAType != null) { 1489 return ImmutableList.of(TAG_gloAlmDeltaTdotAType); 1490 } else { 1491 return Asn1Integer.getPossibleFirstTags(); 1492 } 1493 } 1494 1495 /** 1496 * Creates a new gloAlmDeltaTdotAType from encoded stream. 1497 */ 1498 public static gloAlmDeltaTdotAType fromPerUnaligned(byte[] encodedBytes) { 1499 gloAlmDeltaTdotAType result = new gloAlmDeltaTdotAType(); 1500 result.decodePerUnaligned(new BitStreamReader(encodedBytes)); 1501 return result; 1502 } 1503 1504 /** 1505 * Creates a new gloAlmDeltaTdotAType from encoded stream. 1506 */ 1507 public static gloAlmDeltaTdotAType fromPerAligned(byte[] encodedBytes) { 1508 gloAlmDeltaTdotAType result = new gloAlmDeltaTdotAType(); 1509 result.decodePerAligned(new BitStreamReader(encodedBytes)); 1510 return result; 1511 } 1512 1513 @Override public Iterable<BitStream> encodePerUnaligned() { 1514 return super.encodePerUnaligned(); 1515 } 1516 1517 @Override public Iterable<BitStream> encodePerAligned() { 1518 return super.encodePerAligned(); 1519 } 1520 1521 @Override public void decodePerUnaligned(BitStreamReader reader) { 1522 super.decodePerUnaligned(reader); 1523 } 1524 1525 @Override public void decodePerAligned(BitStreamReader reader) { 1526 super.decodePerAligned(reader); 1527 } 1528 1529 @Override public String toString() { 1530 return toIndentedString(""); 1531 } 1532 1533 public String toIndentedString(String indent) { 1534 return "gloAlmDeltaTdotAType = " + getInteger() + ";\n"; 1535 } 1536 } 1537 1538 1539 /* 1540 */ 1541 1542 1543 // 1544 1545 /** 1546 */ 1547 public static class gloAlmEpsilonAType extends Asn1Integer { 1548 // 1549 1550 private static final Asn1Tag TAG_gloAlmEpsilonAType 1551 = Asn1Tag.fromClassAndNumber(-1, -1); 1552 1553 public gloAlmEpsilonAType() { 1554 super(); 1555 setValueRange("0", "32767"); 1556 1557 } 1558 1559 @Override 1560 @Nullable 1561 protected Asn1Tag getTag() { 1562 return TAG_gloAlmEpsilonAType; 1563 } 1564 1565 @Override 1566 protected boolean isTagImplicit() { 1567 return true; 1568 } 1569 1570 public static Collection<Asn1Tag> getPossibleFirstTags() { 1571 if (TAG_gloAlmEpsilonAType != null) { 1572 return ImmutableList.of(TAG_gloAlmEpsilonAType); 1573 } else { 1574 return Asn1Integer.getPossibleFirstTags(); 1575 } 1576 } 1577 1578 /** 1579 * Creates a new gloAlmEpsilonAType from encoded stream. 1580 */ 1581 public static gloAlmEpsilonAType fromPerUnaligned(byte[] encodedBytes) { 1582 gloAlmEpsilonAType result = new gloAlmEpsilonAType(); 1583 result.decodePerUnaligned(new BitStreamReader(encodedBytes)); 1584 return result; 1585 } 1586 1587 /** 1588 * Creates a new gloAlmEpsilonAType from encoded stream. 1589 */ 1590 public static gloAlmEpsilonAType fromPerAligned(byte[] encodedBytes) { 1591 gloAlmEpsilonAType result = new gloAlmEpsilonAType(); 1592 result.decodePerAligned(new BitStreamReader(encodedBytes)); 1593 return result; 1594 } 1595 1596 @Override public Iterable<BitStream> encodePerUnaligned() { 1597 return super.encodePerUnaligned(); 1598 } 1599 1600 @Override public Iterable<BitStream> encodePerAligned() { 1601 return super.encodePerAligned(); 1602 } 1603 1604 @Override public void decodePerUnaligned(BitStreamReader reader) { 1605 super.decodePerUnaligned(reader); 1606 } 1607 1608 @Override public void decodePerAligned(BitStreamReader reader) { 1609 super.decodePerAligned(reader); 1610 } 1611 1612 @Override public String toString() { 1613 return toIndentedString(""); 1614 } 1615 1616 public String toIndentedString(String indent) { 1617 return "gloAlmEpsilonAType = " + getInteger() + ";\n"; 1618 } 1619 } 1620 1621 1622 /* 1623 */ 1624 1625 1626 // 1627 1628 /** 1629 */ 1630 public static class gloAlmOmegaAType extends Asn1Integer { 1631 // 1632 1633 private static final Asn1Tag TAG_gloAlmOmegaAType 1634 = Asn1Tag.fromClassAndNumber(-1, -1); 1635 1636 public gloAlmOmegaAType() { 1637 super(); 1638 setValueRange("-32768", "32767"); 1639 1640 } 1641 1642 @Override 1643 @Nullable 1644 protected Asn1Tag getTag() { 1645 return TAG_gloAlmOmegaAType; 1646 } 1647 1648 @Override 1649 protected boolean isTagImplicit() { 1650 return true; 1651 } 1652 1653 public static Collection<Asn1Tag> getPossibleFirstTags() { 1654 if (TAG_gloAlmOmegaAType != null) { 1655 return ImmutableList.of(TAG_gloAlmOmegaAType); 1656 } else { 1657 return Asn1Integer.getPossibleFirstTags(); 1658 } 1659 } 1660 1661 /** 1662 * Creates a new gloAlmOmegaAType from encoded stream. 1663 */ 1664 public static gloAlmOmegaAType fromPerUnaligned(byte[] encodedBytes) { 1665 gloAlmOmegaAType result = new gloAlmOmegaAType(); 1666 result.decodePerUnaligned(new BitStreamReader(encodedBytes)); 1667 return result; 1668 } 1669 1670 /** 1671 * Creates a new gloAlmOmegaAType from encoded stream. 1672 */ 1673 public static gloAlmOmegaAType fromPerAligned(byte[] encodedBytes) { 1674 gloAlmOmegaAType result = new gloAlmOmegaAType(); 1675 result.decodePerAligned(new BitStreamReader(encodedBytes)); 1676 return result; 1677 } 1678 1679 @Override public Iterable<BitStream> encodePerUnaligned() { 1680 return super.encodePerUnaligned(); 1681 } 1682 1683 @Override public Iterable<BitStream> encodePerAligned() { 1684 return super.encodePerAligned(); 1685 } 1686 1687 @Override public void decodePerUnaligned(BitStreamReader reader) { 1688 super.decodePerUnaligned(reader); 1689 } 1690 1691 @Override public void decodePerAligned(BitStreamReader reader) { 1692 super.decodePerAligned(reader); 1693 } 1694 1695 @Override public String toString() { 1696 return toIndentedString(""); 1697 } 1698 1699 public String toIndentedString(String indent) { 1700 return "gloAlmOmegaAType = " + getInteger() + ";\n"; 1701 } 1702 } 1703 1704 1705 /* 1706 */ 1707 1708 1709 // 1710 1711 /** 1712 */ 1713 public static class gloAlmTauAType extends Asn1Integer { 1714 // 1715 1716 private static final Asn1Tag TAG_gloAlmTauAType 1717 = Asn1Tag.fromClassAndNumber(-1, -1); 1718 1719 public gloAlmTauAType() { 1720 super(); 1721 setValueRange("-512", "511"); 1722 1723 } 1724 1725 @Override 1726 @Nullable 1727 protected Asn1Tag getTag() { 1728 return TAG_gloAlmTauAType; 1729 } 1730 1731 @Override 1732 protected boolean isTagImplicit() { 1733 return true; 1734 } 1735 1736 public static Collection<Asn1Tag> getPossibleFirstTags() { 1737 if (TAG_gloAlmTauAType != null) { 1738 return ImmutableList.of(TAG_gloAlmTauAType); 1739 } else { 1740 return Asn1Integer.getPossibleFirstTags(); 1741 } 1742 } 1743 1744 /** 1745 * Creates a new gloAlmTauAType from encoded stream. 1746 */ 1747 public static gloAlmTauAType fromPerUnaligned(byte[] encodedBytes) { 1748 gloAlmTauAType result = new gloAlmTauAType(); 1749 result.decodePerUnaligned(new BitStreamReader(encodedBytes)); 1750 return result; 1751 } 1752 1753 /** 1754 * Creates a new gloAlmTauAType from encoded stream. 1755 */ 1756 public static gloAlmTauAType fromPerAligned(byte[] encodedBytes) { 1757 gloAlmTauAType result = new gloAlmTauAType(); 1758 result.decodePerAligned(new BitStreamReader(encodedBytes)); 1759 return result; 1760 } 1761 1762 @Override public Iterable<BitStream> encodePerUnaligned() { 1763 return super.encodePerUnaligned(); 1764 } 1765 1766 @Override public Iterable<BitStream> encodePerAligned() { 1767 return super.encodePerAligned(); 1768 } 1769 1770 @Override public void decodePerUnaligned(BitStreamReader reader) { 1771 super.decodePerUnaligned(reader); 1772 } 1773 1774 @Override public void decodePerAligned(BitStreamReader reader) { 1775 super.decodePerAligned(reader); 1776 } 1777 1778 @Override public String toString() { 1779 return toIndentedString(""); 1780 } 1781 1782 public String toIndentedString(String indent) { 1783 return "gloAlmTauAType = " + getInteger() + ";\n"; 1784 } 1785 } 1786 1787 1788 /* 1789 */ 1790 1791 1792 // 1793 1794 /** 1795 */ 1796 public static class gloAlmCAType extends Asn1Integer { 1797 // 1798 1799 private static final Asn1Tag TAG_gloAlmCAType 1800 = Asn1Tag.fromClassAndNumber(-1, -1); 1801 1802 public gloAlmCAType() { 1803 super(); 1804 setValueRange("0", "1"); 1805 1806 } 1807 1808 @Override 1809 @Nullable 1810 protected Asn1Tag getTag() { 1811 return TAG_gloAlmCAType; 1812 } 1813 1814 @Override 1815 protected boolean isTagImplicit() { 1816 return true; 1817 } 1818 1819 public static Collection<Asn1Tag> getPossibleFirstTags() { 1820 if (TAG_gloAlmCAType != null) { 1821 return ImmutableList.of(TAG_gloAlmCAType); 1822 } else { 1823 return Asn1Integer.getPossibleFirstTags(); 1824 } 1825 } 1826 1827 /** 1828 * Creates a new gloAlmCAType from encoded stream. 1829 */ 1830 public static gloAlmCAType fromPerUnaligned(byte[] encodedBytes) { 1831 gloAlmCAType result = new gloAlmCAType(); 1832 result.decodePerUnaligned(new BitStreamReader(encodedBytes)); 1833 return result; 1834 } 1835 1836 /** 1837 * Creates a new gloAlmCAType from encoded stream. 1838 */ 1839 public static gloAlmCAType fromPerAligned(byte[] encodedBytes) { 1840 gloAlmCAType result = new gloAlmCAType(); 1841 result.decodePerAligned(new BitStreamReader(encodedBytes)); 1842 return result; 1843 } 1844 1845 @Override public Iterable<BitStream> encodePerUnaligned() { 1846 return super.encodePerUnaligned(); 1847 } 1848 1849 @Override public Iterable<BitStream> encodePerAligned() { 1850 return super.encodePerAligned(); 1851 } 1852 1853 @Override public void decodePerUnaligned(BitStreamReader reader) { 1854 super.decodePerUnaligned(reader); 1855 } 1856 1857 @Override public void decodePerAligned(BitStreamReader reader) { 1858 super.decodePerAligned(reader); 1859 } 1860 1861 @Override public String toString() { 1862 return toIndentedString(""); 1863 } 1864 1865 public String toIndentedString(String indent) { 1866 return "gloAlmCAType = " + getInteger() + ";\n"; 1867 } 1868 } 1869 1870 1871 /* 1872 */ 1873 1874 1875 // 1876 1877 /** 1878 */ 1879 public static class gloAlmMAType extends Asn1BitString { 1880 // 1881 1882 private static final Asn1Tag TAG_gloAlmMAType 1883 = Asn1Tag.fromClassAndNumber(-1, -1); 1884 1885 public gloAlmMAType() { 1886 super(); 1887 setMinSize(2); 1888 setMaxSize(2); 1889 1890 } 1891 1892 @Override 1893 @Nullable 1894 protected Asn1Tag getTag() { 1895 return TAG_gloAlmMAType; 1896 } 1897 1898 @Override 1899 protected boolean isTagImplicit() { 1900 return true; 1901 } 1902 1903 public static Collection<Asn1Tag> getPossibleFirstTags() { 1904 if (TAG_gloAlmMAType != null) { 1905 return ImmutableList.of(TAG_gloAlmMAType); 1906 } else { 1907 return Asn1BitString.getPossibleFirstTags(); 1908 } 1909 } 1910 1911 /** 1912 * Creates a new gloAlmMAType from encoded stream. 1913 */ 1914 public static gloAlmMAType fromPerUnaligned(byte[] encodedBytes) { 1915 gloAlmMAType result = new gloAlmMAType(); 1916 result.decodePerUnaligned(new BitStreamReader(encodedBytes)); 1917 return result; 1918 } 1919 1920 /** 1921 * Creates a new gloAlmMAType from encoded stream. 1922 */ 1923 public static gloAlmMAType fromPerAligned(byte[] encodedBytes) { 1924 gloAlmMAType result = new gloAlmMAType(); 1925 result.decodePerAligned(new BitStreamReader(encodedBytes)); 1926 return result; 1927 } 1928 1929 @Override public Iterable<BitStream> encodePerUnaligned() { 1930 return super.encodePerUnaligned(); 1931 } 1932 1933 @Override public Iterable<BitStream> encodePerAligned() { 1934 return super.encodePerAligned(); 1935 } 1936 1937 @Override public void decodePerUnaligned(BitStreamReader reader) { 1938 super.decodePerUnaligned(reader); 1939 } 1940 1941 @Override public void decodePerAligned(BitStreamReader reader) { 1942 super.decodePerAligned(reader); 1943 } 1944 1945 @Override public String toString() { 1946 return toIndentedString(""); 1947 } 1948 1949 public String toIndentedString(String indent) { 1950 return "gloAlmMAType = " + getValue() + ";\n"; 1951 } 1952 } 1953 1954 1955 1956 1957 1958 @Override public Iterable<BitStream> encodePerUnaligned() { 1959 return super.encodePerUnaligned(); 1960 } 1961 1962 @Override public Iterable<BitStream> encodePerAligned() { 1963 return super.encodePerAligned(); 1964 } 1965 1966 @Override public void decodePerUnaligned(BitStreamReader reader) { 1967 super.decodePerUnaligned(reader); 1968 } 1969 1970 @Override public void decodePerAligned(BitStreamReader reader) { 1971 super.decodePerAligned(reader); 1972 } 1973 1974 @Override public String toString() { 1975 return toIndentedString(""); 1976 } 1977 1978 public String toIndentedString(String indent) { 1979 StringBuilder builder = new StringBuilder(); 1980 builder.append("Almanac_GlonassAlmanacSet = {\n"); 1981 final String internalIndent = indent + " "; 1982 for (SequenceComponent component : getComponents()) { 1983 if (component.isExplicitlySet()) { 1984 builder.append(internalIndent) 1985 .append(component.toIndentedString(internalIndent)); 1986 } 1987 } 1988 if (isExtensible()) { 1989 builder.append(internalIndent).append("...\n"); 1990 for (SequenceComponent component : getExtensionComponents()) { 1991 if (component.isExplicitlySet()) { 1992 builder.append(internalIndent) 1993 .append(component.toIndentedString(internalIndent)); 1994 } 1995 } 1996 } 1997 builder.append(indent).append("};\n"); 1998 return builder.toString(); 1999 } 2000 } 2001
