1 /*
2  * Copyright (C) 2017 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 package android.location.cts.asn1.supl2.rrlp_components;
18 
19 /*
20  */
21 
22 
23 //
24 //
25 import android.location.cts.asn1.base.Asn1Integer;
26 import android.location.cts.asn1.base.Asn1Null;
27 import android.location.cts.asn1.base.Asn1Object;
28 import android.location.cts.asn1.base.Asn1Sequence;
29 import android.location.cts.asn1.base.Asn1Tag;
30 import android.location.cts.asn1.base.BitStream;
31 import android.location.cts.asn1.base.BitStreamReader;
32 import android.location.cts.asn1.base.SequenceComponent;
33 import com.google.common.collect.ImmutableList;
34 import java.util.Collection;
35 import javax.annotation.Nullable;
36 
37 
38 /**
39 */
40 public  class GANSS_SgnElement extends Asn1Sequence {
41   //
42 
43   private static final Asn1Tag TAG_GANSS_SgnElement
44       = Asn1Tag.fromClassAndNumber(-1, -1);
45 
GANSS_SgnElement()46   public GANSS_SgnElement() {
47     super();
48   }
49 
50   @Override
51   @Nullable
getTag()52   protected Asn1Tag getTag() {
53     return TAG_GANSS_SgnElement;
54   }
55 
56   @Override
isTagImplicit()57   protected boolean isTagImplicit() {
58     return true;
59   }
60 
getPossibleFirstTags()61   public static Collection<Asn1Tag> getPossibleFirstTags() {
62     if (TAG_GANSS_SgnElement != null) {
63       return ImmutableList.of(TAG_GANSS_SgnElement);
64     } else {
65       return Asn1Sequence.getPossibleFirstTags();
66     }
67   }
68 
69   /**
70    * Creates a new GANSS_SgnElement from encoded stream.
71    */
fromPerUnaligned(byte[] encodedBytes)72   public static GANSS_SgnElement fromPerUnaligned(byte[] encodedBytes) {
73     GANSS_SgnElement result = new GANSS_SgnElement();
74     result.decodePerUnaligned(new BitStreamReader(encodedBytes));
75     return result;
76   }
77 
78   /**
79    * Creates a new GANSS_SgnElement from encoded stream.
80    */
fromPerAligned(byte[] encodedBytes)81   public static GANSS_SgnElement fromPerAligned(byte[] encodedBytes) {
82     GANSS_SgnElement result = new GANSS_SgnElement();
83     result.decodePerAligned(new BitStreamReader(encodedBytes));
84     return result;
85   }
86 
87 
88 
isExtensible()89   @Override protected boolean isExtensible() {
90     return false;
91   }
92 
containsExtensionValues()93   @Override public boolean containsExtensionValues() {
94     for (SequenceComponent extensionComponent : getExtensionComponents()) {
95       if (extensionComponent.isExplicitlySet()) return true;
96     }
97     return false;
98   }
99 
100 
101   private SVID svID_;
getSvID()102   public SVID getSvID() {
103     return svID_;
104   }
105   /**
106    * @throws ClassCastException if value is not a SVID
107    */
setSvID(Asn1Object value)108   public void setSvID(Asn1Object value) {
109     this.svID_ = (SVID) value;
110   }
setSvIDToNewInstance()111   public SVID setSvIDToNewInstance() {
112     svID_ = new SVID();
113     return svID_;
114   }
115 
116   private GANSS_SgnElement.cNoType cNo_;
getCNo()117   public GANSS_SgnElement.cNoType getCNo() {
118     return cNo_;
119   }
120   /**
121    * @throws ClassCastException if value is not a GANSS_SgnElement.cNoType
122    */
setCNo(Asn1Object value)123   public void setCNo(Asn1Object value) {
124     this.cNo_ = (GANSS_SgnElement.cNoType) value;
125   }
setCNoToNewInstance()126   public GANSS_SgnElement.cNoType setCNoToNewInstance() {
127     cNo_ = new GANSS_SgnElement.cNoType();
128     return cNo_;
129   }
130 
131   private MpathIndic mpathDet_;
getMpathDet()132   public MpathIndic getMpathDet() {
133     return mpathDet_;
134   }
135   /**
136    * @throws ClassCastException if value is not a MpathIndic
137    */
setMpathDet(Asn1Object value)138   public void setMpathDet(Asn1Object value) {
139     this.mpathDet_ = (MpathIndic) value;
140   }
setMpathDetToNewInstance()141   public MpathIndic setMpathDetToNewInstance() {
142     mpathDet_ = new MpathIndic();
143     return mpathDet_;
144   }
145 
146   private GANSS_SgnElement.carrierQualityIndType carrierQualityInd_;
getCarrierQualityInd()147   public GANSS_SgnElement.carrierQualityIndType getCarrierQualityInd() {
148     return carrierQualityInd_;
149   }
150   /**
151    * @throws ClassCastException if value is not a GANSS_SgnElement.carrierQualityIndType
152    */
setCarrierQualityInd(Asn1Object value)153   public void setCarrierQualityInd(Asn1Object value) {
154     this.carrierQualityInd_ = (GANSS_SgnElement.carrierQualityIndType) value;
155   }
setCarrierQualityIndToNewInstance()156   public GANSS_SgnElement.carrierQualityIndType setCarrierQualityIndToNewInstance() {
157     carrierQualityInd_ = new GANSS_SgnElement.carrierQualityIndType();
158     return carrierQualityInd_;
159   }
160 
161   private GANSS_SgnElement.codePhaseType codePhase_;
getCodePhase()162   public GANSS_SgnElement.codePhaseType getCodePhase() {
163     return codePhase_;
164   }
165   /**
166    * @throws ClassCastException if value is not a GANSS_SgnElement.codePhaseType
167    */
setCodePhase(Asn1Object value)168   public void setCodePhase(Asn1Object value) {
169     this.codePhase_ = (GANSS_SgnElement.codePhaseType) value;
170   }
setCodePhaseToNewInstance()171   public GANSS_SgnElement.codePhaseType setCodePhaseToNewInstance() {
172     codePhase_ = new GANSS_SgnElement.codePhaseType();
173     return codePhase_;
174   }
175 
176   private GANSS_SgnElement.integerCodePhaseType integerCodePhase_;
getIntegerCodePhase()177   public GANSS_SgnElement.integerCodePhaseType getIntegerCodePhase() {
178     return integerCodePhase_;
179   }
180   /**
181    * @throws ClassCastException if value is not a GANSS_SgnElement.integerCodePhaseType
182    */
setIntegerCodePhase(Asn1Object value)183   public void setIntegerCodePhase(Asn1Object value) {
184     this.integerCodePhase_ = (GANSS_SgnElement.integerCodePhaseType) value;
185   }
setIntegerCodePhaseToNewInstance()186   public GANSS_SgnElement.integerCodePhaseType setIntegerCodePhaseToNewInstance() {
187     integerCodePhase_ = new GANSS_SgnElement.integerCodePhaseType();
188     return integerCodePhase_;
189   }
190 
191   private GANSS_SgnElement.codePhaseRMSErrorType codePhaseRMSError_;
getCodePhaseRMSError()192   public GANSS_SgnElement.codePhaseRMSErrorType getCodePhaseRMSError() {
193     return codePhaseRMSError_;
194   }
195   /**
196    * @throws ClassCastException if value is not a GANSS_SgnElement.codePhaseRMSErrorType
197    */
setCodePhaseRMSError(Asn1Object value)198   public void setCodePhaseRMSError(Asn1Object value) {
199     this.codePhaseRMSError_ = (GANSS_SgnElement.codePhaseRMSErrorType) value;
200   }
setCodePhaseRMSErrorToNewInstance()201   public GANSS_SgnElement.codePhaseRMSErrorType setCodePhaseRMSErrorToNewInstance() {
202     codePhaseRMSError_ = new GANSS_SgnElement.codePhaseRMSErrorType();
203     return codePhaseRMSError_;
204   }
205 
206   private GANSS_SgnElement.dopplerType doppler_;
getDoppler()207   public GANSS_SgnElement.dopplerType getDoppler() {
208     return doppler_;
209   }
210   /**
211    * @throws ClassCastException if value is not a GANSS_SgnElement.dopplerType
212    */
setDoppler(Asn1Object value)213   public void setDoppler(Asn1Object value) {
214     this.doppler_ = (GANSS_SgnElement.dopplerType) value;
215   }
setDopplerToNewInstance()216   public GANSS_SgnElement.dopplerType setDopplerToNewInstance() {
217     doppler_ = new GANSS_SgnElement.dopplerType();
218     return doppler_;
219   }
220 
221   private GANSS_SgnElement.adrType adr_;
getAdr()222   public GANSS_SgnElement.adrType getAdr() {
223     return adr_;
224   }
225   /**
226    * @throws ClassCastException if value is not a GANSS_SgnElement.adrType
227    */
setAdr(Asn1Object value)228   public void setAdr(Asn1Object value) {
229     this.adr_ = (GANSS_SgnElement.adrType) value;
230   }
setAdrToNewInstance()231   public GANSS_SgnElement.adrType setAdrToNewInstance() {
232     adr_ = new GANSS_SgnElement.adrType();
233     return adr_;
234   }
235 
236 
237 
238 
239 
240 
getComponents()241   @Override public Iterable<? extends SequenceComponent> getComponents() {
242     ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
243 
244     builder.add(new SequenceComponent() {
245           Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);
246 
247           @Override public boolean isExplicitlySet() {
248             return getSvID() != null;
249           }
250 
251           @Override public boolean hasDefaultValue() {
252             return false;
253           }
254 
255           @Override public boolean isOptional() {
256             return false;
257           }
258 
259           @Override public Asn1Object getComponentValue() {
260             return getSvID();
261           }
262 
263           @Override public void setToNewInstance() {
264             setSvIDToNewInstance();
265           }
266 
267           @Override public Collection<Asn1Tag> getPossibleFirstTags() {
268             return tag == null ? SVID.getPossibleFirstTags() : ImmutableList.of(tag);
269           }
270 
271           @Override
272           public Asn1Tag getTag() {
273             return tag;
274           }
275 
276           @Override
277           public boolean isImplicitTagging() {
278             return true;
279           }
280 
281           @Override public String toIndentedString(String indent) {
282                 return "svID : "
283                     + getSvID().toIndentedString(indent);
284               }
285         });
286 
287     builder.add(new SequenceComponent() {
288           Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);
289 
290           @Override public boolean isExplicitlySet() {
291             return getCNo() != null;
292           }
293 
294           @Override public boolean hasDefaultValue() {
295             return false;
296           }
297 
298           @Override public boolean isOptional() {
299             return false;
300           }
301 
302           @Override public Asn1Object getComponentValue() {
303             return getCNo();
304           }
305 
306           @Override public void setToNewInstance() {
307             setCNoToNewInstance();
308           }
309 
310           @Override public Collection<Asn1Tag> getPossibleFirstTags() {
311             return tag == null ? GANSS_SgnElement.cNoType.getPossibleFirstTags() : ImmutableList.of(tag);
312           }
313 
314           @Override
315           public Asn1Tag getTag() {
316             return tag;
317           }
318 
319           @Override
320           public boolean isImplicitTagging() {
321             return true;
322           }
323 
324           @Override public String toIndentedString(String indent) {
325                 return "cNo : "
326                     + getCNo().toIndentedString(indent);
327               }
328         });
329 
330     builder.add(new SequenceComponent() {
331           Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);
332 
333           @Override public boolean isExplicitlySet() {
334             return getMpathDet() != null;
335           }
336 
337           @Override public boolean hasDefaultValue() {
338             return false;
339           }
340 
341           @Override public boolean isOptional() {
342             return false;
343           }
344 
345           @Override public Asn1Object getComponentValue() {
346             return getMpathDet();
347           }
348 
349           @Override public void setToNewInstance() {
350             setMpathDetToNewInstance();
351           }
352 
353           @Override public Collection<Asn1Tag> getPossibleFirstTags() {
354             return tag == null ? MpathIndic.getPossibleFirstTags() : ImmutableList.of(tag);
355           }
356 
357           @Override
358           public Asn1Tag getTag() {
359             return tag;
360           }
361 
362           @Override
363           public boolean isImplicitTagging() {
364             return true;
365           }
366 
367           @Override public String toIndentedString(String indent) {
368                 return "mpathDet : "
369                     + getMpathDet().toIndentedString(indent);
370               }
371         });
372 
373     builder.add(new SequenceComponent() {
374           Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 3);
375 
376           @Override public boolean isExplicitlySet() {
377             return getCarrierQualityInd() != null;
378           }
379 
380           @Override public boolean hasDefaultValue() {
381             return false;
382           }
383 
384           @Override public boolean isOptional() {
385             return true;
386           }
387 
388           @Override public Asn1Object getComponentValue() {
389             return getCarrierQualityInd();
390           }
391 
392           @Override public void setToNewInstance() {
393             setCarrierQualityIndToNewInstance();
394           }
395 
396           @Override public Collection<Asn1Tag> getPossibleFirstTags() {
397             return tag == null ? GANSS_SgnElement.carrierQualityIndType.getPossibleFirstTags() : ImmutableList.of(tag);
398           }
399 
400           @Override
401           public Asn1Tag getTag() {
402             return tag;
403           }
404 
405           @Override
406           public boolean isImplicitTagging() {
407             return true;
408           }
409 
410           @Override public String toIndentedString(String indent) {
411                 return "carrierQualityInd : "
412                     + getCarrierQualityInd().toIndentedString(indent);
413               }
414         });
415 
416     builder.add(new SequenceComponent() {
417           Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 4);
418 
419           @Override public boolean isExplicitlySet() {
420             return getCodePhase() != null;
421           }
422 
423           @Override public boolean hasDefaultValue() {
424             return false;
425           }
426 
427           @Override public boolean isOptional() {
428             return false;
429           }
430 
431           @Override public Asn1Object getComponentValue() {
432             return getCodePhase();
433           }
434 
435           @Override public void setToNewInstance() {
436             setCodePhaseToNewInstance();
437           }
438 
439           @Override public Collection<Asn1Tag> getPossibleFirstTags() {
440             return tag == null ? GANSS_SgnElement.codePhaseType.getPossibleFirstTags() : ImmutableList.of(tag);
441           }
442 
443           @Override
444           public Asn1Tag getTag() {
445             return tag;
446           }
447 
448           @Override
449           public boolean isImplicitTagging() {
450             return true;
451           }
452 
453           @Override public String toIndentedString(String indent) {
454                 return "codePhase : "
455                     + getCodePhase().toIndentedString(indent);
456               }
457         });
458 
459     builder.add(new SequenceComponent() {
460           Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 5);
461 
462           @Override public boolean isExplicitlySet() {
463             return getIntegerCodePhase() != null;
464           }
465 
466           @Override public boolean hasDefaultValue() {
467             return false;
468           }
469 
470           @Override public boolean isOptional() {
471             return true;
472           }
473 
474           @Override public Asn1Object getComponentValue() {
475             return getIntegerCodePhase();
476           }
477 
478           @Override public void setToNewInstance() {
479             setIntegerCodePhaseToNewInstance();
480           }
481 
482           @Override public Collection<Asn1Tag> getPossibleFirstTags() {
483             return tag == null ? GANSS_SgnElement.integerCodePhaseType.getPossibleFirstTags() : ImmutableList.of(tag);
484           }
485 
486           @Override
487           public Asn1Tag getTag() {
488             return tag;
489           }
490 
491           @Override
492           public boolean isImplicitTagging() {
493             return true;
494           }
495 
496           @Override public String toIndentedString(String indent) {
497                 return "integerCodePhase : "
498                     + getIntegerCodePhase().toIndentedString(indent);
499               }
500         });
501 
502     builder.add(new SequenceComponent() {
503           Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 6);
504 
505           @Override public boolean isExplicitlySet() {
506             return getCodePhaseRMSError() != null;
507           }
508 
509           @Override public boolean hasDefaultValue() {
510             return false;
511           }
512 
513           @Override public boolean isOptional() {
514             return false;
515           }
516 
517           @Override public Asn1Object getComponentValue() {
518             return getCodePhaseRMSError();
519           }
520 
521           @Override public void setToNewInstance() {
522             setCodePhaseRMSErrorToNewInstance();
523           }
524 
525           @Override public Collection<Asn1Tag> getPossibleFirstTags() {
526             return tag == null ? GANSS_SgnElement.codePhaseRMSErrorType.getPossibleFirstTags() : ImmutableList.of(tag);
527           }
528 
529           @Override
530           public Asn1Tag getTag() {
531             return tag;
532           }
533 
534           @Override
535           public boolean isImplicitTagging() {
536             return true;
537           }
538 
539           @Override public String toIndentedString(String indent) {
540                 return "codePhaseRMSError : "
541                     + getCodePhaseRMSError().toIndentedString(indent);
542               }
543         });
544 
545     builder.add(new SequenceComponent() {
546           Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 7);
547 
548           @Override public boolean isExplicitlySet() {
549             return getDoppler() != null;
550           }
551 
552           @Override public boolean hasDefaultValue() {
553             return false;
554           }
555 
556           @Override public boolean isOptional() {
557             return true;
558           }
559 
560           @Override public Asn1Object getComponentValue() {
561             return getDoppler();
562           }
563 
564           @Override public void setToNewInstance() {
565             setDopplerToNewInstance();
566           }
567 
568           @Override public Collection<Asn1Tag> getPossibleFirstTags() {
569             return tag == null ? GANSS_SgnElement.dopplerType.getPossibleFirstTags() : ImmutableList.of(tag);
570           }
571 
572           @Override
573           public Asn1Tag getTag() {
574             return tag;
575           }
576 
577           @Override
578           public boolean isImplicitTagging() {
579             return true;
580           }
581 
582           @Override public String toIndentedString(String indent) {
583                 return "doppler : "
584                     + getDoppler().toIndentedString(indent);
585               }
586         });
587 
588     builder.add(new SequenceComponent() {
589           Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 8);
590 
591           @Override public boolean isExplicitlySet() {
592             return getAdr() != null;
593           }
594 
595           @Override public boolean hasDefaultValue() {
596             return false;
597           }
598 
599           @Override public boolean isOptional() {
600             return true;
601           }
602 
603           @Override public Asn1Object getComponentValue() {
604             return getAdr();
605           }
606 
607           @Override public void setToNewInstance() {
608             setAdrToNewInstance();
609           }
610 
611           @Override public Collection<Asn1Tag> getPossibleFirstTags() {
612             return tag == null ? GANSS_SgnElement.adrType.getPossibleFirstTags() : ImmutableList.of(tag);
613           }
614 
615           @Override
616           public Asn1Tag getTag() {
617             return tag;
618           }
619 
620           @Override
621           public boolean isImplicitTagging() {
622             return true;
623           }
624 
625           @Override public String toIndentedString(String indent) {
626                 return "adr : "
627                     + getAdr().toIndentedString(indent);
628               }
629         });
630 
631     return builder.build();
632   }
633 
634   @Override public Iterable<? extends SequenceComponent>
getExtensionComponents()635                                                     getExtensionComponents() {
636     ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();
637 
638       return builder.build();
639     }
640 
641 
642 
643 
644 /*
645  */
646 
647 
648 //
649 
650 /**
651  */
652 public static class cNoType extends Asn1Integer {
653   //
654 
655   private static final Asn1Tag TAG_cNoType
656       = Asn1Tag.fromClassAndNumber(-1, -1);
657 
cNoType()658   public cNoType() {
659     super();
660     setValueRange("0", "63");
661 
662   }
663 
664   @Override
665   @Nullable
getTag()666   protected Asn1Tag getTag() {
667     return TAG_cNoType;
668   }
669 
670   @Override
isTagImplicit()671   protected boolean isTagImplicit() {
672     return true;
673   }
674 
getPossibleFirstTags()675   public static Collection<Asn1Tag> getPossibleFirstTags() {
676     if (TAG_cNoType != null) {
677       return ImmutableList.of(TAG_cNoType);
678     } else {
679       return Asn1Integer.getPossibleFirstTags();
680     }
681   }
682 
683   /**
684    * Creates a new cNoType from encoded stream.
685    */
fromPerUnaligned(byte[] encodedBytes)686   public static cNoType fromPerUnaligned(byte[] encodedBytes) {
687     cNoType result = new cNoType();
688     result.decodePerUnaligned(new BitStreamReader(encodedBytes));
689     return result;
690   }
691 
692   /**
693    * Creates a new cNoType from encoded stream.
694    */
fromPerAligned(byte[] encodedBytes)695   public static cNoType fromPerAligned(byte[] encodedBytes) {
696     cNoType result = new cNoType();
697     result.decodePerAligned(new BitStreamReader(encodedBytes));
698     return result;
699   }
700 
encodePerUnaligned()701   @Override public Iterable<BitStream> encodePerUnaligned() {
702     return super.encodePerUnaligned();
703   }
704 
encodePerAligned()705   @Override public Iterable<BitStream> encodePerAligned() {
706     return super.encodePerAligned();
707   }
708 
decodePerUnaligned(BitStreamReader reader)709   @Override public void decodePerUnaligned(BitStreamReader reader) {
710     super.decodePerUnaligned(reader);
711   }
712 
decodePerAligned(BitStreamReader reader)713   @Override public void decodePerAligned(BitStreamReader reader) {
714     super.decodePerAligned(reader);
715   }
716 
toString()717   @Override public String toString() {
718     return toIndentedString("");
719   }
720 
toIndentedString(String indent)721   public String toIndentedString(String indent) {
722     return "cNoType = " + getInteger() + ";\n";
723   }
724 }
725 
726 
727 
728 
729 /*
730  */
731 
732 
733 //
734 
735 /**
736  */
737 public static class carrierQualityIndType extends Asn1Integer {
738   //
739 
740   private static final Asn1Tag TAG_carrierQualityIndType
741       = Asn1Tag.fromClassAndNumber(-1, -1);
742 
carrierQualityIndType()743   public carrierQualityIndType() {
744     super();
745     setValueRange("0", "3");
746 
747   }
748 
749   @Override
750   @Nullable
getTag()751   protected Asn1Tag getTag() {
752     return TAG_carrierQualityIndType;
753   }
754 
755   @Override
isTagImplicit()756   protected boolean isTagImplicit() {
757     return true;
758   }
759 
getPossibleFirstTags()760   public static Collection<Asn1Tag> getPossibleFirstTags() {
761     if (TAG_carrierQualityIndType != null) {
762       return ImmutableList.of(TAG_carrierQualityIndType);
763     } else {
764       return Asn1Integer.getPossibleFirstTags();
765     }
766   }
767 
768   /**
769    * Creates a new carrierQualityIndType from encoded stream.
770    */
fromPerUnaligned(byte[] encodedBytes)771   public static carrierQualityIndType fromPerUnaligned(byte[] encodedBytes) {
772     carrierQualityIndType result = new carrierQualityIndType();
773     result.decodePerUnaligned(new BitStreamReader(encodedBytes));
774     return result;
775   }
776 
777   /**
778    * Creates a new carrierQualityIndType from encoded stream.
779    */
fromPerAligned(byte[] encodedBytes)780   public static carrierQualityIndType fromPerAligned(byte[] encodedBytes) {
781     carrierQualityIndType result = new carrierQualityIndType();
782     result.decodePerAligned(new BitStreamReader(encodedBytes));
783     return result;
784   }
785 
encodePerUnaligned()786   @Override public Iterable<BitStream> encodePerUnaligned() {
787     return super.encodePerUnaligned();
788   }
789 
encodePerAligned()790   @Override public Iterable<BitStream> encodePerAligned() {
791     return super.encodePerAligned();
792   }
793 
decodePerUnaligned(BitStreamReader reader)794   @Override public void decodePerUnaligned(BitStreamReader reader) {
795     super.decodePerUnaligned(reader);
796   }
797 
decodePerAligned(BitStreamReader reader)798   @Override public void decodePerAligned(BitStreamReader reader) {
799     super.decodePerAligned(reader);
800   }
801 
toString()802   @Override public String toString() {
803     return toIndentedString("");
804   }
805 
toIndentedString(String indent)806   public String toIndentedString(String indent) {
807     return "carrierQualityIndType = " + getInteger() + ";\n";
808   }
809 }
810 
811 
812 /*
813  */
814 
815 
816 //
817 
818 /**
819  */
820 public static class codePhaseType extends Asn1Integer {
821   //
822 
823   private static final Asn1Tag TAG_codePhaseType
824       = Asn1Tag.fromClassAndNumber(-1, -1);
825 
codePhaseType()826   public codePhaseType() {
827     super();
828     setValueRange("0", "2097151");
829 
830   }
831 
832   @Override
833   @Nullable
getTag()834   protected Asn1Tag getTag() {
835     return TAG_codePhaseType;
836   }
837 
838   @Override
isTagImplicit()839   protected boolean isTagImplicit() {
840     return true;
841   }
842 
getPossibleFirstTags()843   public static Collection<Asn1Tag> getPossibleFirstTags() {
844     if (TAG_codePhaseType != null) {
845       return ImmutableList.of(TAG_codePhaseType);
846     } else {
847       return Asn1Integer.getPossibleFirstTags();
848     }
849   }
850 
851   /**
852    * Creates a new codePhaseType from encoded stream.
853    */
fromPerUnaligned(byte[] encodedBytes)854   public static codePhaseType fromPerUnaligned(byte[] encodedBytes) {
855     codePhaseType result = new codePhaseType();
856     result.decodePerUnaligned(new BitStreamReader(encodedBytes));
857     return result;
858   }
859 
860   /**
861    * Creates a new codePhaseType from encoded stream.
862    */
fromPerAligned(byte[] encodedBytes)863   public static codePhaseType fromPerAligned(byte[] encodedBytes) {
864     codePhaseType result = new codePhaseType();
865     result.decodePerAligned(new BitStreamReader(encodedBytes));
866     return result;
867   }
868 
encodePerUnaligned()869   @Override public Iterable<BitStream> encodePerUnaligned() {
870     return super.encodePerUnaligned();
871   }
872 
encodePerAligned()873   @Override public Iterable<BitStream> encodePerAligned() {
874     return super.encodePerAligned();
875   }
876 
decodePerUnaligned(BitStreamReader reader)877   @Override public void decodePerUnaligned(BitStreamReader reader) {
878     super.decodePerUnaligned(reader);
879   }
880 
decodePerAligned(BitStreamReader reader)881   @Override public void decodePerAligned(BitStreamReader reader) {
882     super.decodePerAligned(reader);
883   }
884 
toString()885   @Override public String toString() {
886     return toIndentedString("");
887   }
888 
toIndentedString(String indent)889   public String toIndentedString(String indent) {
890     return "codePhaseType = " + getInteger() + ";\n";
891   }
892 }
893 
894 
895 /*
896  */
897 
898 
899 //
900 
901 /**
902  */
903 public static class integerCodePhaseType extends Asn1Integer {
904   //
905 
906   private static final Asn1Tag TAG_integerCodePhaseType
907       = Asn1Tag.fromClassAndNumber(-1, -1);
908 
integerCodePhaseType()909   public integerCodePhaseType() {
910     super();
911     setValueRange("0", "127");
912 
913   }
914 
915   @Override
916   @Nullable
getTag()917   protected Asn1Tag getTag() {
918     return TAG_integerCodePhaseType;
919   }
920 
921   @Override
isTagImplicit()922   protected boolean isTagImplicit() {
923     return true;
924   }
925 
getPossibleFirstTags()926   public static Collection<Asn1Tag> getPossibleFirstTags() {
927     if (TAG_integerCodePhaseType != null) {
928       return ImmutableList.of(TAG_integerCodePhaseType);
929     } else {
930       return Asn1Integer.getPossibleFirstTags();
931     }
932   }
933 
934   /**
935    * Creates a new integerCodePhaseType from encoded stream.
936    */
fromPerUnaligned(byte[] encodedBytes)937   public static integerCodePhaseType fromPerUnaligned(byte[] encodedBytes) {
938     integerCodePhaseType result = new integerCodePhaseType();
939     result.decodePerUnaligned(new BitStreamReader(encodedBytes));
940     return result;
941   }
942 
943   /**
944    * Creates a new integerCodePhaseType from encoded stream.
945    */
fromPerAligned(byte[] encodedBytes)946   public static integerCodePhaseType fromPerAligned(byte[] encodedBytes) {
947     integerCodePhaseType result = new integerCodePhaseType();
948     result.decodePerAligned(new BitStreamReader(encodedBytes));
949     return result;
950   }
951 
encodePerUnaligned()952   @Override public Iterable<BitStream> encodePerUnaligned() {
953     return super.encodePerUnaligned();
954   }
955 
encodePerAligned()956   @Override public Iterable<BitStream> encodePerAligned() {
957     return super.encodePerAligned();
958   }
959 
decodePerUnaligned(BitStreamReader reader)960   @Override public void decodePerUnaligned(BitStreamReader reader) {
961     super.decodePerUnaligned(reader);
962   }
963 
decodePerAligned(BitStreamReader reader)964   @Override public void decodePerAligned(BitStreamReader reader) {
965     super.decodePerAligned(reader);
966   }
967 
toString()968   @Override public String toString() {
969     return toIndentedString("");
970   }
971 
toIndentedString(String indent)972   public String toIndentedString(String indent) {
973     return "integerCodePhaseType = " + getInteger() + ";\n";
974   }
975 }
976 
977 
978 /*
979  */
980 
981 
982 //
983 
984 /**
985  */
986 public static class codePhaseRMSErrorType extends Asn1Integer {
987   //
988 
989   private static final Asn1Tag TAG_codePhaseRMSErrorType
990       = Asn1Tag.fromClassAndNumber(-1, -1);
991 
codePhaseRMSErrorType()992   public codePhaseRMSErrorType() {
993     super();
994     setValueRange("0", "63");
995 
996   }
997 
998   @Override
999   @Nullable
getTag()1000   protected Asn1Tag getTag() {
1001     return TAG_codePhaseRMSErrorType;
1002   }
1003 
1004   @Override
isTagImplicit()1005   protected boolean isTagImplicit() {
1006     return true;
1007   }
1008 
getPossibleFirstTags()1009   public static Collection<Asn1Tag> getPossibleFirstTags() {
1010     if (TAG_codePhaseRMSErrorType != null) {
1011       return ImmutableList.of(TAG_codePhaseRMSErrorType);
1012     } else {
1013       return Asn1Integer.getPossibleFirstTags();
1014     }
1015   }
1016 
1017   /**
1018    * Creates a new codePhaseRMSErrorType from encoded stream.
1019    */
fromPerUnaligned(byte[] encodedBytes)1020   public static codePhaseRMSErrorType fromPerUnaligned(byte[] encodedBytes) {
1021     codePhaseRMSErrorType result = new codePhaseRMSErrorType();
1022     result.decodePerUnaligned(new BitStreamReader(encodedBytes));
1023     return result;
1024   }
1025 
1026   /**
1027    * Creates a new codePhaseRMSErrorType from encoded stream.
1028    */
fromPerAligned(byte[] encodedBytes)1029   public static codePhaseRMSErrorType fromPerAligned(byte[] encodedBytes) {
1030     codePhaseRMSErrorType result = new codePhaseRMSErrorType();
1031     result.decodePerAligned(new BitStreamReader(encodedBytes));
1032     return result;
1033   }
1034 
encodePerUnaligned()1035   @Override public Iterable<BitStream> encodePerUnaligned() {
1036     return super.encodePerUnaligned();
1037   }
1038 
encodePerAligned()1039   @Override public Iterable<BitStream> encodePerAligned() {
1040     return super.encodePerAligned();
1041   }
1042 
decodePerUnaligned(BitStreamReader reader)1043   @Override public void decodePerUnaligned(BitStreamReader reader) {
1044     super.decodePerUnaligned(reader);
1045   }
1046 
decodePerAligned(BitStreamReader reader)1047   @Override public void decodePerAligned(BitStreamReader reader) {
1048     super.decodePerAligned(reader);
1049   }
1050 
toString()1051   @Override public String toString() {
1052     return toIndentedString("");
1053   }
1054 
toIndentedString(String indent)1055   public String toIndentedString(String indent) {
1056     return "codePhaseRMSErrorType = " + getInteger() + ";\n";
1057   }
1058 }
1059 
1060 
1061 /*
1062  */
1063 
1064 
1065 //
1066 
1067 /**
1068  */
1069 public static class dopplerType extends Asn1Integer {
1070   //
1071 
1072   private static final Asn1Tag TAG_dopplerType
1073       = Asn1Tag.fromClassAndNumber(-1, -1);
1074 
dopplerType()1075   public dopplerType() {
1076     super();
1077     setValueRange("-32768", "32767");
1078 
1079   }
1080 
1081   @Override
1082   @Nullable
getTag()1083   protected Asn1Tag getTag() {
1084     return TAG_dopplerType;
1085   }
1086 
1087   @Override
isTagImplicit()1088   protected boolean isTagImplicit() {
1089     return true;
1090   }
1091 
getPossibleFirstTags()1092   public static Collection<Asn1Tag> getPossibleFirstTags() {
1093     if (TAG_dopplerType != null) {
1094       return ImmutableList.of(TAG_dopplerType);
1095     } else {
1096       return Asn1Integer.getPossibleFirstTags();
1097     }
1098   }
1099 
1100   /**
1101    * Creates a new dopplerType from encoded stream.
1102    */
fromPerUnaligned(byte[] encodedBytes)1103   public static dopplerType fromPerUnaligned(byte[] encodedBytes) {
1104     dopplerType result = new dopplerType();
1105     result.decodePerUnaligned(new BitStreamReader(encodedBytes));
1106     return result;
1107   }
1108 
1109   /**
1110    * Creates a new dopplerType from encoded stream.
1111    */
fromPerAligned(byte[] encodedBytes)1112   public static dopplerType fromPerAligned(byte[] encodedBytes) {
1113     dopplerType result = new dopplerType();
1114     result.decodePerAligned(new BitStreamReader(encodedBytes));
1115     return result;
1116   }
1117 
encodePerUnaligned()1118   @Override public Iterable<BitStream> encodePerUnaligned() {
1119     return super.encodePerUnaligned();
1120   }
1121 
encodePerAligned()1122   @Override public Iterable<BitStream> encodePerAligned() {
1123     return super.encodePerAligned();
1124   }
1125 
decodePerUnaligned(BitStreamReader reader)1126   @Override public void decodePerUnaligned(BitStreamReader reader) {
1127     super.decodePerUnaligned(reader);
1128   }
1129 
decodePerAligned(BitStreamReader reader)1130   @Override public void decodePerAligned(BitStreamReader reader) {
1131     super.decodePerAligned(reader);
1132   }
1133 
toString()1134   @Override public String toString() {
1135     return toIndentedString("");
1136   }
1137 
toIndentedString(String indent)1138   public String toIndentedString(String indent) {
1139     return "dopplerType = " + getInteger() + ";\n";
1140   }
1141 }
1142 
1143 
1144 /*
1145  */
1146 
1147 
1148 //
1149 
1150 /**
1151  */
1152 public static class adrType extends Asn1Integer {
1153   //
1154 
1155   private static final Asn1Tag TAG_adrType
1156       = Asn1Tag.fromClassAndNumber(-1, -1);
1157 
adrType()1158   public adrType() {
1159     super();
1160     setValueRange("0", "33554431");
1161 
1162   }
1163 
1164   @Override
1165   @Nullable
getTag()1166   protected Asn1Tag getTag() {
1167     return TAG_adrType;
1168   }
1169 
1170   @Override
isTagImplicit()1171   protected boolean isTagImplicit() {
1172     return true;
1173   }
1174 
getPossibleFirstTags()1175   public static Collection<Asn1Tag> getPossibleFirstTags() {
1176     if (TAG_adrType != null) {
1177       return ImmutableList.of(TAG_adrType);
1178     } else {
1179       return Asn1Integer.getPossibleFirstTags();
1180     }
1181   }
1182 
1183   /**
1184    * Creates a new adrType from encoded stream.
1185    */
fromPerUnaligned(byte[] encodedBytes)1186   public static adrType fromPerUnaligned(byte[] encodedBytes) {
1187     adrType result = new adrType();
1188     result.decodePerUnaligned(new BitStreamReader(encodedBytes));
1189     return result;
1190   }
1191 
1192   /**
1193    * Creates a new adrType from encoded stream.
1194    */
fromPerAligned(byte[] encodedBytes)1195   public static adrType fromPerAligned(byte[] encodedBytes) {
1196     adrType result = new adrType();
1197     result.decodePerAligned(new BitStreamReader(encodedBytes));
1198     return result;
1199   }
1200 
encodePerUnaligned()1201   @Override public Iterable<BitStream> encodePerUnaligned() {
1202     return super.encodePerUnaligned();
1203   }
1204 
encodePerAligned()1205   @Override public Iterable<BitStream> encodePerAligned() {
1206     return super.encodePerAligned();
1207   }
1208 
decodePerUnaligned(BitStreamReader reader)1209   @Override public void decodePerUnaligned(BitStreamReader reader) {
1210     super.decodePerUnaligned(reader);
1211   }
1212 
decodePerAligned(BitStreamReader reader)1213   @Override public void decodePerAligned(BitStreamReader reader) {
1214     super.decodePerAligned(reader);
1215   }
1216 
toString()1217   @Override public String toString() {
1218     return toIndentedString("");
1219   }
1220 
toIndentedString(String indent)1221   public String toIndentedString(String indent) {
1222     return "adrType = " + getInteger() + ";\n";
1223   }
1224 }
1225 
1226 
1227 
1228 
1229 
encodePerUnaligned()1230   @Override public Iterable<BitStream> encodePerUnaligned() {
1231     return super.encodePerUnaligned();
1232   }
1233 
encodePerAligned()1234   @Override public Iterable<BitStream> encodePerAligned() {
1235     return super.encodePerAligned();
1236   }
1237 
decodePerUnaligned(BitStreamReader reader)1238   @Override public void decodePerUnaligned(BitStreamReader reader) {
1239     super.decodePerUnaligned(reader);
1240   }
1241 
decodePerAligned(BitStreamReader reader)1242   @Override public void decodePerAligned(BitStreamReader reader) {
1243     super.decodePerAligned(reader);
1244   }
1245 
toString()1246   @Override public String toString() {
1247     return toIndentedString("");
1248   }
1249 
toIndentedString(String indent)1250   public String toIndentedString(String indent) {
1251     StringBuilder builder = new StringBuilder();
1252     builder.append("GANSS_SgnElement = {\n");
1253     final String internalIndent = indent + "  ";
1254     for (SequenceComponent component : getComponents()) {
1255       if (component.isExplicitlySet()) {
1256         builder.append(internalIndent)
1257             .append(component.toIndentedString(internalIndent));
1258       }
1259     }
1260     if (isExtensible()) {
1261       builder.append(internalIndent).append("...\n");
1262       for (SequenceComponent component : getExtensionComponents()) {
1263         if (component.isExplicitlySet()) {
1264           builder.append(internalIndent)
1265               .append(component.toIndentedString(internalIndent));
1266         }
1267       }
1268     }
1269     builder.append(indent).append("};\n");
1270     return builder.toString();
1271   }
1272 }
1273