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_message_extensions;
18 
19 /*
20  */
21 
22 
23 //
24 //
25 import android.location.cts.asn1.base.Asn1Integer;
26 import android.location.cts.asn1.base.Asn1Null;
27 import android.location.cts.asn1.base.Asn1Object;
28 import android.location.cts.asn1.base.Asn1Sequence;
29 import android.location.cts.asn1.base.Asn1Tag;
30 import android.location.cts.asn1.base.BitStream;
31 import android.location.cts.asn1.base.BitStreamReader;
32 import android.location.cts.asn1.base.SequenceComponent;
33 import android.location.cts.asn1.supl2.supl_triggered_start.TriggerType;
34 import android.location.cts.asn1.supl2.ulp_components.SLPAddress;
35 import android.location.cts.asn1.supl2.ver2_ulp_components.GNSSPosTechnology;
36 import android.location.cts.asn1.supl2.ver2_ulp_components.SupportedNetworkInformation;
37 import com.google.common.collect.ImmutableList;
38 import java.util.Collection;
39 import javax.annotation.Nullable;
40 
41 
42 /**
43 */
44 public  class Ver2_SUPL_INIT_extension extends Asn1Sequence {
45   //
46 
47   private static final Asn1Tag TAG_Ver2_SUPL_INIT_extension
48       = Asn1Tag.fromClassAndNumber(-1, -1);
49 
Ver2_SUPL_INIT_extension()50   public Ver2_SUPL_INIT_extension() {
51     super();
52   }
53 
54   @Override
55   @Nullable
getTag()56   protected Asn1Tag getTag() {
57     return TAG_Ver2_SUPL_INIT_extension;
58   }
59 
60   @Override
isTagImplicit()61   protected boolean isTagImplicit() {
62     return true;
63   }
64 
getPossibleFirstTags()65   public static Collection<Asn1Tag> getPossibleFirstTags() {
66     if (TAG_Ver2_SUPL_INIT_extension != null) {
67       return ImmutableList.of(TAG_Ver2_SUPL_INIT_extension);
68     } else {
69       return Asn1Sequence.getPossibleFirstTags();
70     }
71   }
72 
73   /**
74    * Creates a new Ver2_SUPL_INIT_extension from encoded stream.
75    */
fromPerUnaligned(byte[] encodedBytes)76   public static Ver2_SUPL_INIT_extension fromPerUnaligned(byte[] encodedBytes) {
77     Ver2_SUPL_INIT_extension result = new Ver2_SUPL_INIT_extension();
78     result.decodePerUnaligned(new BitStreamReader(encodedBytes));
79     return result;
80   }
81 
82   /**
83    * Creates a new Ver2_SUPL_INIT_extension from encoded stream.
84    */
fromPerAligned(byte[] encodedBytes)85   public static Ver2_SUPL_INIT_extension fromPerAligned(byte[] encodedBytes) {
86     Ver2_SUPL_INIT_extension result = new Ver2_SUPL_INIT_extension();
87     result.decodePerAligned(new BitStreamReader(encodedBytes));
88     return result;
89   }
90 
91 
92 
isExtensible()93   @Override protected boolean isExtensible() {
94     return true;
95   }
96 
containsExtensionValues()97   @Override public boolean containsExtensionValues() {
98     for (SequenceComponent extensionComponent : getExtensionComponents()) {
99       if (extensionComponent.isExplicitlySet()) return true;
100     }
101     return false;
102   }
103 
104 
105   private NotificationMode notificationMode_;
getNotificationMode()106   public NotificationMode getNotificationMode() {
107     return notificationMode_;
108   }
109   /**
110    * @throws ClassCastException if value is not a NotificationMode
111    */
setNotificationMode(Asn1Object value)112   public void setNotificationMode(Asn1Object value) {
113     this.notificationMode_ = (NotificationMode) value;
114   }
setNotificationModeToNewInstance()115   public NotificationMode setNotificationModeToNewInstance() {
116     notificationMode_ = new NotificationMode();
117     return notificationMode_;
118   }
119 
120   private SupportedNetworkInformation supportedNetworkInformation_;
getSupportedNetworkInformation()121   public SupportedNetworkInformation getSupportedNetworkInformation() {
122     return supportedNetworkInformation_;
123   }
124   /**
125    * @throws ClassCastException if value is not a SupportedNetworkInformation
126    */
setSupportedNetworkInformation(Asn1Object value)127   public void setSupportedNetworkInformation(Asn1Object value) {
128     this.supportedNetworkInformation_ = (SupportedNetworkInformation) value;
129   }
setSupportedNetworkInformationToNewInstance()130   public SupportedNetworkInformation setSupportedNetworkInformationToNewInstance() {
131     supportedNetworkInformation_ = new SupportedNetworkInformation();
132     return supportedNetworkInformation_;
133   }
134 
135   private TriggerType triggerType_;
getTriggerType()136   public TriggerType getTriggerType() {
137     return triggerType_;
138   }
139   /**
140    * @throws ClassCastException if value is not a TriggerType
141    */
setTriggerType(Asn1Object value)142   public void setTriggerType(Asn1Object value) {
143     this.triggerType_ = (TriggerType) value;
144   }
setTriggerTypeToNewInstance()145   public TriggerType setTriggerTypeToNewInstance() {
146     triggerType_ = new TriggerType();
147     return triggerType_;
148   }
149 
150   private SLPAddress e_SLPAddress_;
getE_SLPAddress()151   public SLPAddress getE_SLPAddress() {
152     return e_SLPAddress_;
153   }
154   /**
155    * @throws ClassCastException if value is not a SLPAddress
156    */
setE_SLPAddress(Asn1Object value)157   public void setE_SLPAddress(Asn1Object value) {
158     this.e_SLPAddress_ = (SLPAddress) value;
159   }
setE_SLPAddressToNewInstance()160   public SLPAddress setE_SLPAddressToNewInstance() {
161     e_SLPAddress_ = new SLPAddress();
162     return e_SLPAddress_;
163   }
164 
165   private HistoricReporting historicReporting_;
getHistoricReporting()166   public HistoricReporting getHistoricReporting() {
167     return historicReporting_;
168   }
169   /**
170    * @throws ClassCastException if value is not a HistoricReporting
171    */
setHistoricReporting(Asn1Object value)172   public void setHistoricReporting(Asn1Object value) {
173     this.historicReporting_ = (HistoricReporting) value;
174   }
setHistoricReportingToNewInstance()175   public HistoricReporting setHistoricReportingToNewInstance() {
176     historicReporting_ = new HistoricReporting();
177     return historicReporting_;
178   }
179 
180   private ProtectionLevel protectionLevel_;
getProtectionLevel()181   public ProtectionLevel getProtectionLevel() {
182     return protectionLevel_;
183   }
184   /**
185    * @throws ClassCastException if value is not a ProtectionLevel
186    */
setProtectionLevel(Asn1Object value)187   public void setProtectionLevel(Asn1Object value) {
188     this.protectionLevel_ = (ProtectionLevel) value;
189   }
setProtectionLevelToNewInstance()190   public ProtectionLevel setProtectionLevelToNewInstance() {
191     protectionLevel_ = new ProtectionLevel();
192     return protectionLevel_;
193   }
194 
195   private GNSSPosTechnology gnssPosTechnology_;
getGnssPosTechnology()196   public GNSSPosTechnology getGnssPosTechnology() {
197     return gnssPosTechnology_;
198   }
199   /**
200    * @throws ClassCastException if value is not a GNSSPosTechnology
201    */
setGnssPosTechnology(Asn1Object value)202   public void setGnssPosTechnology(Asn1Object value) {
203     this.gnssPosTechnology_ = (GNSSPosTechnology) value;
204   }
setGnssPosTechnologyToNewInstance()205   public GNSSPosTechnology setGnssPosTechnologyToNewInstance() {
206     gnssPosTechnology_ = new GNSSPosTechnology();
207     return gnssPosTechnology_;
208   }
209 
210   private Ver2_SUPL_INIT_extension.minimumMajorVersionType minimumMajorVersion_;
getMinimumMajorVersion()211   public Ver2_SUPL_INIT_extension.minimumMajorVersionType getMinimumMajorVersion() {
212     return minimumMajorVersion_;
213   }
214   /**
215    * @throws ClassCastException if value is not a Ver2_SUPL_INIT_extension.minimumMajorVersionType
216    */
setMinimumMajorVersion(Asn1Object value)217   public void setMinimumMajorVersion(Asn1Object value) {
218     this.minimumMajorVersion_ = (Ver2_SUPL_INIT_extension.minimumMajorVersionType) value;
219   }
setMinimumMajorVersionToNewInstance()220   public Ver2_SUPL_INIT_extension.minimumMajorVersionType setMinimumMajorVersionToNewInstance() {
221     minimumMajorVersion_ = new Ver2_SUPL_INIT_extension.minimumMajorVersionType();
222     return minimumMajorVersion_;
223   }
224 
225 
226 
227 
228 
229 
getComponents()230   @Override public Iterable<? extends SequenceComponent> getComponents() {
231     ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
232 
233     builder.add(new SequenceComponent() {
234           Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
235 
236           @Override public boolean isExplicitlySet() {
237             return getNotificationMode() != null;
238           }
239 
240           @Override public boolean hasDefaultValue() {
241             return false;
242           }
243 
244           @Override public boolean isOptional() {
245             return true;
246           }
247 
248           @Override public Asn1Object getComponentValue() {
249             return getNotificationMode();
250           }
251 
252           @Override public void setToNewInstance() {
253             setNotificationModeToNewInstance();
254           }
255 
256           @Override public Collection<Asn1Tag> getPossibleFirstTags() {
257             return tag == null ? NotificationMode.getPossibleFirstTags() : ImmutableList.of(tag);
258           }
259 
260           @Override
261           public Asn1Tag getTag() {
262             return tag;
263           }
264 
265           @Override
266           public boolean isImplicitTagging() {
267             return true;
268           }
269 
270           @Override public String toIndentedString(String indent) {
271                 return "notificationMode : "
272                     + getNotificationMode().toIndentedString(indent);
273               }
274         });
275 
276     builder.add(new SequenceComponent() {
277           Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
278 
279           @Override public boolean isExplicitlySet() {
280             return getSupportedNetworkInformation() != null;
281           }
282 
283           @Override public boolean hasDefaultValue() {
284             return false;
285           }
286 
287           @Override public boolean isOptional() {
288             return true;
289           }
290 
291           @Override public Asn1Object getComponentValue() {
292             return getSupportedNetworkInformation();
293           }
294 
295           @Override public void setToNewInstance() {
296             setSupportedNetworkInformationToNewInstance();
297           }
298 
299           @Override public Collection<Asn1Tag> getPossibleFirstTags() {
300             return tag == null ? SupportedNetworkInformation.getPossibleFirstTags() : ImmutableList.of(tag);
301           }
302 
303           @Override
304           public Asn1Tag getTag() {
305             return tag;
306           }
307 
308           @Override
309           public boolean isImplicitTagging() {
310             return true;
311           }
312 
313           @Override public String toIndentedString(String indent) {
314                 return "supportedNetworkInformation : "
315                     + getSupportedNetworkInformation().toIndentedString(indent);
316               }
317         });
318 
319     builder.add(new SequenceComponent() {
320           Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
321 
322           @Override public boolean isExplicitlySet() {
323             return getTriggerType() != null;
324           }
325 
326           @Override public boolean hasDefaultValue() {
327             return false;
328           }
329 
330           @Override public boolean isOptional() {
331             return true;
332           }
333 
334           @Override public Asn1Object getComponentValue() {
335             return getTriggerType();
336           }
337 
338           @Override public void setToNewInstance() {
339             setTriggerTypeToNewInstance();
340           }
341 
342           @Override public Collection<Asn1Tag> getPossibleFirstTags() {
343             return tag == null ? TriggerType.getPossibleFirstTags() : ImmutableList.of(tag);
344           }
345 
346           @Override
347           public Asn1Tag getTag() {
348             return tag;
349           }
350 
351           @Override
352           public boolean isImplicitTagging() {
353             return true;
354           }
355 
356           @Override public String toIndentedString(String indent) {
357                 return "triggerType : "
358                     + getTriggerType().toIndentedString(indent);
359               }
360         });
361 
362     builder.add(new SequenceComponent() {
363           Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
364 
365           @Override public boolean isExplicitlySet() {
366             return getE_SLPAddress() != null;
367           }
368 
369           @Override public boolean hasDefaultValue() {
370             return false;
371           }
372 
373           @Override public boolean isOptional() {
374             return true;
375           }
376 
377           @Override public Asn1Object getComponentValue() {
378             return getE_SLPAddress();
379           }
380 
381           @Override public void setToNewInstance() {
382             setE_SLPAddressToNewInstance();
383           }
384 
385           @Override public Collection<Asn1Tag> getPossibleFirstTags() {
386             return tag == null ? SLPAddress.getPossibleFirstTags() : ImmutableList.of(tag);
387           }
388 
389           @Override
390           public Asn1Tag getTag() {
391             return tag;
392           }
393 
394           @Override
395           public boolean isImplicitTagging() {
396             return true;
397           }
398 
399           @Override public String toIndentedString(String indent) {
400                 return "e_SLPAddress : "
401                     + getE_SLPAddress().toIndentedString(indent);
402               }
403         });
404 
405     builder.add(new SequenceComponent() {
406           Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
407 
408           @Override public boolean isExplicitlySet() {
409             return getHistoricReporting() != null;
410           }
411 
412           @Override public boolean hasDefaultValue() {
413             return false;
414           }
415 
416           @Override public boolean isOptional() {
417             return true;
418           }
419 
420           @Override public Asn1Object getComponentValue() {
421             return getHistoricReporting();
422           }
423 
424           @Override public void setToNewInstance() {
425             setHistoricReportingToNewInstance();
426           }
427 
428           @Override public Collection<Asn1Tag> getPossibleFirstTags() {
429             return tag == null ? HistoricReporting.getPossibleFirstTags() : ImmutableList.of(tag);
430           }
431 
432           @Override
433           public Asn1Tag getTag() {
434             return tag;
435           }
436 
437           @Override
438           public boolean isImplicitTagging() {
439             return true;
440           }
441 
442           @Override public String toIndentedString(String indent) {
443                 return "historicReporting : "
444                     + getHistoricReporting().toIndentedString(indent);
445               }
446         });
447 
448     builder.add(new SequenceComponent() {
449           Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 5);
450 
451           @Override public boolean isExplicitlySet() {
452             return getProtectionLevel() != null;
453           }
454 
455           @Override public boolean hasDefaultValue() {
456             return false;
457           }
458 
459           @Override public boolean isOptional() {
460             return true;
461           }
462 
463           @Override public Asn1Object getComponentValue() {
464             return getProtectionLevel();
465           }
466 
467           @Override public void setToNewInstance() {
468             setProtectionLevelToNewInstance();
469           }
470 
471           @Override public Collection<Asn1Tag> getPossibleFirstTags() {
472             return tag == null ? ProtectionLevel.getPossibleFirstTags() : ImmutableList.of(tag);
473           }
474 
475           @Override
476           public Asn1Tag getTag() {
477             return tag;
478           }
479 
480           @Override
481           public boolean isImplicitTagging() {
482             return true;
483           }
484 
485           @Override public String toIndentedString(String indent) {
486                 return "protectionLevel : "
487                     + getProtectionLevel().toIndentedString(indent);
488               }
489         });
490 
491     builder.add(new SequenceComponent() {
492           Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 6);
493 
494           @Override public boolean isExplicitlySet() {
495             return getGnssPosTechnology() != null;
496           }
497 
498           @Override public boolean hasDefaultValue() {
499             return false;
500           }
501 
502           @Override public boolean isOptional() {
503             return true;
504           }
505 
506           @Override public Asn1Object getComponentValue() {
507             return getGnssPosTechnology();
508           }
509 
510           @Override public void setToNewInstance() {
511             setGnssPosTechnologyToNewInstance();
512           }
513 
514           @Override public Collection<Asn1Tag> getPossibleFirstTags() {
515             return tag == null ? GNSSPosTechnology.getPossibleFirstTags() : ImmutableList.of(tag);
516           }
517 
518           @Override
519           public Asn1Tag getTag() {
520             return tag;
521           }
522 
523           @Override
524           public boolean isImplicitTagging() {
525             return true;
526           }
527 
528           @Override public String toIndentedString(String indent) {
529                 return "gnssPosTechnology : "
530                     + getGnssPosTechnology().toIndentedString(indent);
531               }
532         });
533 
534     builder.add(new SequenceComponent() {
535           Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 7);
536 
537           @Override public boolean isExplicitlySet() {
538             return getMinimumMajorVersion() != null;
539           }
540 
541           @Override public boolean hasDefaultValue() {
542             return false;
543           }
544 
545           @Override public boolean isOptional() {
546             return true;
547           }
548 
549           @Override public Asn1Object getComponentValue() {
550             return getMinimumMajorVersion();
551           }
552 
553           @Override public void setToNewInstance() {
554             setMinimumMajorVersionToNewInstance();
555           }
556 
557           @Override public Collection<Asn1Tag> getPossibleFirstTags() {
558             return tag == null ? Ver2_SUPL_INIT_extension.minimumMajorVersionType.getPossibleFirstTags() : ImmutableList.of(tag);
559           }
560 
561           @Override
562           public Asn1Tag getTag() {
563             return tag;
564           }
565 
566           @Override
567           public boolean isImplicitTagging() {
568             return true;
569           }
570 
571           @Override public String toIndentedString(String indent) {
572                 return "minimumMajorVersion : "
573                     + getMinimumMajorVersion().toIndentedString(indent);
574               }
575         });
576 
577     return builder.build();
578   }
579 
580   @Override public Iterable<? extends SequenceComponent>
getExtensionComponents()581                                                     getExtensionComponents() {
582     ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
583 
584       return builder.build();
585     }
586 
587 
588 
589 
590 
591 
592 
593 
594 
595 
596 
597 
598 
599 
600 
601 
602 /*
603  */
604 
605 
606 //
607 
608 /**
609  */
610 public static class minimumMajorVersionType extends Asn1Integer {
611   //
612 
613   private static final Asn1Tag TAG_minimumMajorVersionType
614       = Asn1Tag.fromClassAndNumber(-1, -1);
615 
minimumMajorVersionType()616   public minimumMajorVersionType() {
617     super();
618     setValueRange("0", "255");
619 
620   }
621 
622   @Override
623   @Nullable
getTag()624   protected Asn1Tag getTag() {
625     return TAG_minimumMajorVersionType;
626   }
627 
628   @Override
isTagImplicit()629   protected boolean isTagImplicit() {
630     return true;
631   }
632 
getPossibleFirstTags()633   public static Collection<Asn1Tag> getPossibleFirstTags() {
634     if (TAG_minimumMajorVersionType != null) {
635       return ImmutableList.of(TAG_minimumMajorVersionType);
636     } else {
637       return Asn1Integer.getPossibleFirstTags();
638     }
639   }
640 
641   /**
642    * Creates a new minimumMajorVersionType from encoded stream.
643    */
fromPerUnaligned(byte[] encodedBytes)644   public static minimumMajorVersionType fromPerUnaligned(byte[] encodedBytes) {
645     minimumMajorVersionType result = new minimumMajorVersionType();
646     result.decodePerUnaligned(new BitStreamReader(encodedBytes));
647     return result;
648   }
649 
650   /**
651    * Creates a new minimumMajorVersionType from encoded stream.
652    */
fromPerAligned(byte[] encodedBytes)653   public static minimumMajorVersionType fromPerAligned(byte[] encodedBytes) {
654     minimumMajorVersionType result = new minimumMajorVersionType();
655     result.decodePerAligned(new BitStreamReader(encodedBytes));
656     return result;
657   }
658 
encodePerUnaligned()659   @Override public Iterable<BitStream> encodePerUnaligned() {
660     return super.encodePerUnaligned();
661   }
662 
encodePerAligned()663   @Override public Iterable<BitStream> encodePerAligned() {
664     return super.encodePerAligned();
665   }
666 
decodePerUnaligned(BitStreamReader reader)667   @Override public void decodePerUnaligned(BitStreamReader reader) {
668     super.decodePerUnaligned(reader);
669   }
670 
decodePerAligned(BitStreamReader reader)671   @Override public void decodePerAligned(BitStreamReader reader) {
672     super.decodePerAligned(reader);
673   }
674 
toString()675   @Override public String toString() {
676     return toIndentedString("");
677   }
678 
toIndentedString(String indent)679   public String toIndentedString(String indent) {
680     return "minimumMajorVersionType = " + getInteger() + ";\n";
681   }
682 }
683 
684 
685 
686 
687 
encodePerUnaligned()688   @Override public Iterable<BitStream> encodePerUnaligned() {
689     return super.encodePerUnaligned();
690   }
691 
encodePerAligned()692   @Override public Iterable<BitStream> encodePerAligned() {
693     return super.encodePerAligned();
694   }
695 
decodePerUnaligned(BitStreamReader reader)696   @Override public void decodePerUnaligned(BitStreamReader reader) {
697     super.decodePerUnaligned(reader);
698   }
699 
decodePerAligned(BitStreamReader reader)700   @Override public void decodePerAligned(BitStreamReader reader) {
701     super.decodePerAligned(reader);
702   }
703 
toString()704   @Override public String toString() {
705     return toIndentedString("");
706   }
707 
toIndentedString(String indent)708   public String toIndentedString(String indent) {
709     StringBuilder builder = new StringBuilder();
710     builder.append("Ver2_SUPL_INIT_extension = {\n");
711     final String internalIndent = indent + "  ";
712     for (SequenceComponent component : getComponents()) {
713       if (component.isExplicitlySet()) {
714         builder.append(internalIndent)
715             .append(component.toIndentedString(internalIndent));
716       }
717     }
718     if (isExtensible()) {
719       builder.append(internalIndent).append("...\n");
720       for (SequenceComponent component : getExtensionComponents()) {
721         if (component.isExplicitlySet()) {
722           builder.append(internalIndent)
723               .append(component.toIndentedString(internalIndent));
724         }
725       }
726     }
727     builder.append(indent).append("};\n");
728     return builder.toString();
729   }
730 }
731