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.Asn1Choice; 26 import android.location.cts.asn1.base.Asn1Null; 27 import android.location.cts.asn1.base.Asn1Object; 28 import android.location.cts.asn1.base.Asn1Tag; 29 import android.location.cts.asn1.base.BitStream; 30 import android.location.cts.asn1.base.BitStreamReader; 31 import android.location.cts.asn1.base.ChoiceComponent; 32 import com.google.common.collect.ImmutableList; 33 import java.nio.ByteBuffer; 34 import java.util.Collection; 35 import java.util.HashMap; 36 import java.util.Map; 37 import javax.annotation.Nullable; 38 39 40 /** 41 */ 42 public class GANSSAlmanacElement extends Asn1Choice { 43 // 44 45 private static final Asn1Tag TAG_GANSSAlmanacElement 46 = Asn1Tag.fromClassAndNumber(-1, -1); 47 48 private static final Map<Asn1Tag, Select> tagToSelection = new HashMap<>(); 49 50 private boolean extension; 51 private ChoiceComponent selection; 52 private Asn1Object element; 53 54 static { 55 for (Select select : Select.values()) { 56 for (Asn1Tag tag : select.getPossibleFirstTags()) { 57 Select select0; 58 if ((select0 = tagToSelection.put(tag, select)) != null) { 59 throw new IllegalStateException( 60 "GANSSAlmanacElement: " + tag + " maps to both " + select0 + " and " + select); 61 } 62 } 63 } 64 } 65 66 public GANSSAlmanacElement() { 67 super(); 68 } 69 70 @Override 71 @Nullable 72 protected Asn1Tag getTag() { 73 return TAG_GANSSAlmanacElement; 74 } 75 76 @Override 77 protected boolean isTagImplicit() { 78 return true; 79 } 80 81 public static Collection<Asn1Tag> getPossibleFirstTags() { 82 if (TAG_GANSSAlmanacElement != null) { 83 return ImmutableList.of(TAG_GANSSAlmanacElement); 84 } else { 85 return tagToSelection.keySet(); 86 } 87 } 88 89 /** 90 * Creates a new GANSSAlmanacElement from encoded stream. 91 */ 92 public static GANSSAlmanacElement fromPerUnaligned(byte[] encodedBytes) { 93 GANSSAlmanacElement result = new GANSSAlmanacElement(); 94 result.decodePerUnaligned(new BitStreamReader(encodedBytes)); 95 return result; 96 } 97 98 /** 99 * Creates a new GANSSAlmanacElement from encoded stream. 100 */ 101 public static GANSSAlmanacElement fromPerAligned(byte[] encodedBytes) { 102 GANSSAlmanacElement result = new GANSSAlmanacElement(); 103 result.decodePerAligned(new BitStreamReader(encodedBytes)); 104 return result; 105 } 106 107 108 109 @Override protected boolean hasExtensionValue() { 110 return extension; 111 } 112 113 @Override protected Integer getSelectionOrdinal() { 114 return selection.ordinal(); 115 } 116 117 @Nullable 118 @Override 119 protected ChoiceComponent getSelectedComponent() { 120 return selection; 121 } 122 123 @Override protected int getOptionCount() { 124 if (hasExtensionValue()) { 125 return Extend.values().length; 126 } 127 return Select.values().length; 128 } 129 130 protected Asn1Object createAndSetValue(boolean isExtensionValue, 131 int ordinal) { 132 extension = isExtensionValue; 133 if (isExtensionValue) { 134 selection = Extend.values()[ordinal]; 135 } else { 136 selection = Select.values()[ordinal]; 137 } 138 element = selection.createElement(); 139 return element; 140 } 141 142 @Override protected ChoiceComponent createAndSetValue(Asn1Tag tag) { 143 Select select = tagToSelection.get(tag); 144 if (select == null) { 145 throw new IllegalArgumentException("Unknown selection tag: " + tag); 146 } 147 element = select.createElement(); 148 selection = select; 149 extension = false; 150 return select; 151 } 152 153 @Override protected boolean isExtensible() { 154 return true; 155 } 156 157 @Override protected Asn1Object getValue() { 158 return element; 159 } 160 161 162 private static enum Select implements ChoiceComponent { 163 164 $KeplerianAlmanacSet(Asn1Tag.fromClassAndNumber(2, 0), 165 true) { 166 @Override 167 public Asn1Object createElement() { 168 return new Almanac_KeplerianSet(); 169 } 170 171 @Override 172 Collection<Asn1Tag> getPossibleFirstTags() { 173 return tag == null ? Almanac_KeplerianSet.getPossibleFirstTags() : ImmutableList.of(tag); 174 } 175 176 @Override 177 String elementIndentedString(Asn1Object element, String indent) { 178 return toString() + " : " + element.toIndentedString(indent); 179 } 180 }, 181 182 ; 183 184 @Nullable final Asn1Tag tag; 185 final boolean isImplicitTagging; 186 187 Select(@Nullable Asn1Tag tag, boolean isImplicitTagging) { 188 this.tag = tag; 189 this.isImplicitTagging = isImplicitTagging; 190 } 191 192 @Override 193 public Asn1Object createElement() { 194 throw new IllegalStateException("Select template error"); 195 } 196 197 @Override 198 @Nullable 199 public Asn1Tag getTag() { 200 return tag; 201 } 202 203 @Override 204 public boolean isImplicitTagging() { 205 return isImplicitTagging; 206 } 207 208 abstract Collection<Asn1Tag> getPossibleFirstTags(); 209 210 abstract String elementIndentedString(Asn1Object element, String indent); 211 } 212 213 214 215 public boolean isKeplerianAlmanacSet() { 216 return !hasExtensionValue() && Select.$KeplerianAlmanacSet == selection; 217 } 218 219 /** 220 * @throws {@code IllegalStateException} if {@code !isKeplerianAlmanacSet}. 221 */ 222 @SuppressWarnings("unchecked") 223 public Almanac_KeplerianSet getKeplerianAlmanacSet() { 224 if (!isKeplerianAlmanacSet()) { 225 throw new IllegalStateException("GANSSAlmanacElement value not a KeplerianAlmanacSet"); 226 } 227 return (Almanac_KeplerianSet) element; 228 } 229 230 public void setKeplerianAlmanacSet(Almanac_KeplerianSet selected) { 231 selection = Select.$KeplerianAlmanacSet; 232 extension = false; 233 element = selected; 234 } 235 236 public Almanac_KeplerianSet setKeplerianAlmanacSetToNewInstance() { 237 Almanac_KeplerianSet element = new Almanac_KeplerianSet(); 238 setKeplerianAlmanacSet(element); 239 return element; 240 } 241 242 243 private static enum Extend implements ChoiceComponent { 244 245 $KeplerianNAVAlmanac(Asn1Tag.fromClassAndNumber(2, 1), 246 true) { 247 @Override 248 public Asn1Object createElement() { 249 return new Almanac_NAVKeplerianSet(); 250 } 251 252 @Override 253 @SuppressWarnings("unchecked") 254 String elementIndentedString(Asn1Object element, String indent) { 255 return toString() + " : " + ((Almanac_NAVKeplerianSet) element).toIndentedString(indent); 256 } 257 }, 258 259 $KeplerianReducedAlmanac(Asn1Tag.fromClassAndNumber(2, 2), 260 true) { 261 @Override 262 public Asn1Object createElement() { 263 return new Almanac_ReducedKeplerianSet(); 264 } 265 266 @Override 267 @SuppressWarnings("unchecked") 268 String elementIndentedString(Asn1Object element, String indent) { 269 return toString() + " : " + ((Almanac_ReducedKeplerianSet) element).toIndentedString(indent); 270 } 271 }, 272 273 $KeplerianMidiAlmanac(Asn1Tag.fromClassAndNumber(2, 3), 274 true) { 275 @Override 276 public Asn1Object createElement() { 277 return new Almanac_MidiAlmanacSet(); 278 } 279 280 @Override 281 @SuppressWarnings("unchecked") 282 String elementIndentedString(Asn1Object element, String indent) { 283 return toString() + " : " + ((Almanac_MidiAlmanacSet) element).toIndentedString(indent); 284 } 285 }, 286 287 $KeplerianGLONASS(Asn1Tag.fromClassAndNumber(2, 4), 288 true) { 289 @Override 290 public Asn1Object createElement() { 291 return new Almanac_GlonassAlmanacSet(); 292 } 293 294 @Override 295 @SuppressWarnings("unchecked") 296 String elementIndentedString(Asn1Object element, String indent) { 297 return toString() + " : " + ((Almanac_GlonassAlmanacSet) element).toIndentedString(indent); 298 } 299 }, 300 301 $EcefSBASAlmanac(Asn1Tag.fromClassAndNumber(2, 5), 302 true) { 303 @Override 304 public Asn1Object createElement() { 305 return new Almanac_ECEFsbasAlmanacSet(); 306 } 307 308 @Override 309 @SuppressWarnings("unchecked") 310 String elementIndentedString(Asn1Object element, String indent) { 311 return toString() + " : " + ((Almanac_ECEFsbasAlmanacSet) element).toIndentedString(indent); 312 } 313 }, 314 315 ; 316 @Nullable private final Asn1Tag tag; 317 private final boolean isImplicitTagging; 318 319 Extend(@Nullable Asn1Tag tag, boolean isImplicitTagging) { 320 this.tag = tag; 321 this.isImplicitTagging = isImplicitTagging; 322 } 323 324 public Asn1Object createElement() { 325 throw new IllegalStateException("Extend template error"); 326 } 327 328 @Override 329 @Nullable 330 public Asn1Tag getTag() { 331 return tag; 332 } 333 334 @Override 335 public boolean isImplicitTagging() { 336 return isImplicitTagging; 337 } 338 339 String elementIndentedString(Asn1Object element, String indent) { 340 throw new IllegalStateException("Extend template error"); 341 } 342 } 343 344 345 346 public boolean isExtensionKeplerianNAVAlmanac() { 347 return hasExtensionValue() && Extend.$KeplerianNAVAlmanac == selection; 348 } 349 350 /** 351 * @throws {@code IllegalStateException} if {@code !isKeplerianNAVAlmanac}. 352 */ 353 @SuppressWarnings("unchecked") 354 public Almanac_NAVKeplerianSet getExtensionKeplerianNAVAlmanac() { 355 if (!isExtensionKeplerianNAVAlmanac()) { 356 throw new IllegalStateException("GANSSAlmanacElement value not a KeplerianNAVAlmanac"); 357 } 358 return (Almanac_NAVKeplerianSet) element; 359 } 360 361 public void setExtensionKeplerianNAVAlmanac(Almanac_NAVKeplerianSet selected) { 362 selection = Extend.$KeplerianNAVAlmanac; 363 extension = true; 364 element = selected; 365 } 366 367 public void setExtensionKeplerianNAVAlmanacToNewInstance() { 368 Almanac_NAVKeplerianSet element = new Almanac_NAVKeplerianSet(); 369 setExtensionKeplerianNAVAlmanac(element); 370 } 371 372 373 374 public boolean isExtensionKeplerianReducedAlmanac() { 375 return hasExtensionValue() && Extend.$KeplerianReducedAlmanac == selection; 376 } 377 378 /** 379 * @throws {@code IllegalStateException} if {@code !isKeplerianReducedAlmanac}. 380 */ 381 @SuppressWarnings("unchecked") 382 public Almanac_ReducedKeplerianSet getExtensionKeplerianReducedAlmanac() { 383 if (!isExtensionKeplerianReducedAlmanac()) { 384 throw new IllegalStateException("GANSSAlmanacElement value not a KeplerianReducedAlmanac"); 385 } 386 return (Almanac_ReducedKeplerianSet) element; 387 } 388 389 public void setExtensionKeplerianReducedAlmanac(Almanac_ReducedKeplerianSet selected) { 390 selection = Extend.$KeplerianReducedAlmanac; 391 extension = true; 392 element = selected; 393 } 394 395 public void setExtensionKeplerianReducedAlmanacToNewInstance() { 396 Almanac_ReducedKeplerianSet element = new Almanac_ReducedKeplerianSet(); 397 setExtensionKeplerianReducedAlmanac(element); 398 } 399 400 401 402 public boolean isExtensionKeplerianMidiAlmanac() { 403 return hasExtensionValue() && Extend.$KeplerianMidiAlmanac == selection; 404 } 405 406 /** 407 * @throws {@code IllegalStateException} if {@code !isKeplerianMidiAlmanac}. 408 */ 409 @SuppressWarnings("unchecked") 410 public Almanac_MidiAlmanacSet getExtensionKeplerianMidiAlmanac() { 411 if (!isExtensionKeplerianMidiAlmanac()) { 412 throw new IllegalStateException("GANSSAlmanacElement value not a KeplerianMidiAlmanac"); 413 } 414 return (Almanac_MidiAlmanacSet) element; 415 } 416 417 public void setExtensionKeplerianMidiAlmanac(Almanac_MidiAlmanacSet selected) { 418 selection = Extend.$KeplerianMidiAlmanac; 419 extension = true; 420 element = selected; 421 } 422 423 public void setExtensionKeplerianMidiAlmanacToNewInstance() { 424 Almanac_MidiAlmanacSet element = new Almanac_MidiAlmanacSet(); 425 setExtensionKeplerianMidiAlmanac(element); 426 } 427 428 429 430 public boolean isExtensionKeplerianGLONASS() { 431 return hasExtensionValue() && Extend.$KeplerianGLONASS == selection; 432 } 433 434 /** 435 * @throws {@code IllegalStateException} if {@code !isKeplerianGLONASS}. 436 */ 437 @SuppressWarnings("unchecked") 438 public Almanac_GlonassAlmanacSet getExtensionKeplerianGLONASS() { 439 if (!isExtensionKeplerianGLONASS()) { 440 throw new IllegalStateException("GANSSAlmanacElement value not a KeplerianGLONASS"); 441 } 442 return (Almanac_GlonassAlmanacSet) element; 443 } 444 445 public void setExtensionKeplerianGLONASS(Almanac_GlonassAlmanacSet selected) { 446 selection = Extend.$KeplerianGLONASS; 447 extension = true; 448 element = selected; 449 } 450 451 public void setExtensionKeplerianGLONASSToNewInstance() { 452 Almanac_GlonassAlmanacSet element = new Almanac_GlonassAlmanacSet(); 453 setExtensionKeplerianGLONASS(element); 454 } 455 456 457 458 public boolean isExtensionEcefSBASAlmanac() { 459 return hasExtensionValue() && Extend.$EcefSBASAlmanac == selection; 460 } 461 462 /** 463 * @throws {@code IllegalStateException} if {@code !isEcefSBASAlmanac}. 464 */ 465 @SuppressWarnings("unchecked") 466 public Almanac_ECEFsbasAlmanacSet getExtensionEcefSBASAlmanac() { 467 if (!isExtensionEcefSBASAlmanac()) { 468 throw new IllegalStateException("GANSSAlmanacElement value not a EcefSBASAlmanac"); 469 } 470 return (Almanac_ECEFsbasAlmanacSet) element; 471 } 472 473 public void setExtensionEcefSBASAlmanac(Almanac_ECEFsbasAlmanacSet selected) { 474 selection = Extend.$EcefSBASAlmanac; 475 extension = true; 476 element = selected; 477 } 478 479 public void setExtensionEcefSBASAlmanacToNewInstance() { 480 Almanac_ECEFsbasAlmanacSet element = new Almanac_ECEFsbasAlmanacSet(); 481 setExtensionEcefSBASAlmanac(element); 482 } 483 484 485 @Override public Iterable<BitStream> encodePerUnaligned() { 486 return super.encodePerUnaligned(); 487 } 488 489 @Override public Iterable<BitStream> encodePerAligned() { 490 return super.encodePerAligned(); 491 } 492 493 @Override public void decodePerUnaligned(BitStreamReader reader) { 494 super.decodePerUnaligned(reader); 495 } 496 497 @Override public void decodePerAligned(BitStreamReader reader) { 498 super.decodePerAligned(reader); 499 } 500 501 @Override public String toString() { 502 return toIndentedString(""); 503 } 504 505 private String elementIndentedString(String indent) { 506 if (element == null) { 507 return "null;\n"; 508 } 509 if (extension) { 510 return Extend.values()[selection.ordinal()] 511 .elementIndentedString(element, indent + " "); 512 } else { 513 return Select.values()[selection.ordinal()] 514 .elementIndentedString(element, indent + " "); 515 } 516 } 517 518 public String toIndentedString(String indent) { 519 return "GANSSAlmanacElement = " + elementIndentedString(indent) + indent + ";\n"; 520 } 521 } 522